Module viiaStatus

This module contais the classes for the project constants and status parameters.

Project

Class ViiaProject

This is the base class for any script run. It contains the info on the model and binds all functionality to the project object.

class viiapackage.viiaStatus.ViiaProject(name: str, analysis_type: Optional[str] = None, analysis_subtype: Optional[str] = None, token: Optional[str] = None)[source]

Bases: Project

This class extends the Project class for the VIIA environment. The project contains general project setup, and facilitates the binding of the methods used in the VIIA project.

__init__(name: str, analysis_type: Optional[str] = None, analysis_subtype: Optional[str] = None, token: Optional[str] = None)[source]

Input:

name (str): Name of the project to be created.
analysis_type (str): Select the type of analysis performed. Within VIIA currently ‘MRS’, ‘SBS’, ‘NLTH’ and ‘NLPO’ are available. Default is None.
analysis_subtype (str): Select the push-over approach, single line ‘SL’ or multiline ‘ML’. This argument is only used in non-linear push-over analysis (analysis type ‘NLPO’). Default value is None.
token (str): Optional input to provide the token for access to MYVIIA database. Input only used when script is performed on MYVIIA server environment.

find_max_id(collection: list)

Function to find the highest used number in the ID attribute of the objects. This function is viia specific, and overwrites the function defines in the fem-package. The difference between this function and the one in the fem-package, is that this function skips the ids of cavity walls. Since they are set to start at 9000.

Input:

project (obj): Viia Project object containing collections of fem objects and project variables.
collection (list with object references): List of the objects for which the ID attribute will be checked.

Output:

Returns the highest integer found in the collection of items.

geometry_creation(geometry_name: str, material_object: Material, shape_object: Optional[Union[Shapes, str]] = None, class_type: Optional[str] = None)

This function contains all settings for the geometries that are set by the naming convention used in the VIIA project. These settings are project specific. If geometry names that are passed are not conform naming convention, an error may be raised.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
geometry_name (str): Name of the geometry, using the standard for VIIA project (see UPR).
material_object (obj): Object reference to the material of the shape.
shape_object (obj): Object reference to the shape the material is applied on. If class_type is provided the shape is not required. Default value is None. Required if the class_type is not provided.
class_type (str): Optional input of the type of object to apply the geometry on, for example ‘Floor’ or ‘Lintel’, default value is None. Required if the shape_object is not provided.

Output:

Updates the geometry name depending on the VIIA project settings.
Returns the object reference to the geometry (if not present, it is created)

get_myviia_object_deel_id() → int[source]: This method of ‘ViiaProject’ will return the objectpart ID in MYVIIA database, based on the given retrieved project information at initialisation of the class.

property importance_factor: float: Returns the value of the importance factor, depends on the consequence class.

material_creation(material_name: str, hbv_span: Optional[float] = None, hbv_width: Optional[float] = None)

This function contains all settings for the materials that are set by the naming convention used in the VIIA project. These settings are project specific. If material names that are passed are not conform naming convention, an error may be raised.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
material_name (str): Name of the material, using the standard for VIIA project (see UPR).
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:

Updates the material name depending on the VIIA project settings.
Returns the object reference to the material (if not present, it is created)

pile_foundation_present() → bool[source]: Method of ‘ViiaProject’ to check if there is a pile foundation present in the model.

shallow_foundation_present() → bool[source]: Method of ‘ViiaProject’ to check if there is a shallow foundation present in the model.

update_package(package: str = None, version: str = None, extra_index_url: str = None)[source]

Function to update (or install) a package.

Input:

package (str): Package that needs to be updated. Default is None. When None viiapackage will be updated.
version (str): Version of the package that need to be installed. Default is None. When None the latest available version will be installed.
extra_index_url (str): The extra index url for private packages. Default is None. When None and the package is viiapackage, the index-url of viiapackage will be used.

Output:

Package is updated and script is exited.

viia_AutoResizeAllWalls()

This function resizes all walls automatically. Pay attention when using, unwanted walls may be shortened.

Note

All walls must be defined in the viia Python Database.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

The points of the Auto resized walls will be updated in the python database.

viia_acceleration_graphs(tb_file: Path, signal: str, analysis: Analysis, acceleration_nodes: Optional[List[int]] = None, final_timestep: Optional[int] = None, diff_gap: int = 1) → Optional[List[Path]]

For a given signal, this function generates three graphs that present the acceleration of the building in x-, y- and z-directions. The acceleration is plotted for three locations; Base acceleration, foundation acceleration and far field acceleration. For foundation and top of building, a node must be provided from which to extract the acceleration data.

Note

The accelerations are calculated based on numerical differentiation of the displacements of the mesh-nodes Be aware that the tb-file values may contain unexpected noise.

Input:

project (obj): Project object containing collections and of fem objects and project variables.
tb_file_loc (Path): Location of the tb-file.
signal (str): String representing the signal, can be S1 to S11.
analysis (obj): Object reference of analysis of the results in the tb-file.
acceleration_nodes (list of int): A list of nodes that user specified to collect acceleration, these nodes are specified by the ID of the mesh-node.
final_timestep (int): Optional timestep up to which to plot the signal and the accelerations.
diff_gap (int): Gap between the two consecutive time steps considered for numerical differentiation. Default value 1. Only required if numerical differentiation is applied.

Output:

This function generates three plots in a new folder ‘A12 Acceleration Graphs’, describing the acceleration of the building in x-, y- and z-direction in three different locations. The folder and the three files are return in a tuple (order: folder, x, y- and z-graph).

viia_add_basemotion_signals(signal_list: Optional[Union[List[int], str]] = None, use_unmatched_signals: bool = False) → TimeseriesCombinationSet

This function applies the accelerations on the supports (surface of the shallow foundation, or piles). It can be applied in fixed or flexbase calculations. The normalised signals will be used to find the correct signal for the building, using the cluster and the AgS of the location.

Warning

Some signals can have deviating time-steps. Please check the log.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
signal_list (list): Specification of the list of signals which need to be imported into PY-memory. Default value None, applying the signals 1, 2, 3, 5, 6, 7 and 9 as the other signals have deviating time-steps. Items in list should be integers 1 to 11. Default value is None, selecting default selection of signals. Input can also be provided as string, only ‘default’ is available.
use_unmatched_signals (bool): Switch to use the signals which an unmatched z-component. Default value False. The matched signals are used by default.

Output:

Signals are added to class of TimeseriesCombinationSet, notification is given.

viia_add_floor_openings(floor: Floor, opening_list: List[List], starting_point: Optional[Union[List[float], Node]] = None, direction: Optional[Union[List[float], Direction]] = None, flip: bool = False) → Floor

Function to easily add openings to floors, based on measurements commonly specified in inspection data. This function is used by viia_add_openings, if a floor object is detected. Openings are specified by supplying a list of four values; distance to opening in given direction, length of the opening, distance perpendicular to that line and width of opening. Any next opening is defined continuing along the given direction.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
floor (obj): Object reference of floor on which the opening(s) are applied.
opening_list (list): List that contains the data for the openings. All measurements should be given in [m].
starting_point (list of 2 floats): The starting point from which the measurements are taken. If not provided the first point of the floor definition is used. The z-coordinate of the point if given will be overwritten with the z-coordinate of the floor. Alternative input is providing a Node. It is not required that the starting point is on the floor, the opening points should.
direction (list of 2 floats): Direction from starting point that the dimensions are recorded in the inspection. If not provided the spanning direction of the floor is used for the direction of the dimension. Alternative input is providing a Direction. The direction is always only derived in the horizontal plane.
flip (bool): Select to flip the direction in which the openings are added to the shape. Default value False.

Output:

The opening(s) are added to the floor.
The floor shape is returned.

Example:

The following example shows a floor on which two openings are added. First one starting on x=0 and y=1.8 relative to the first point of the floor and in the direction of the local x-axis. The first opening has a width of 1.1m and length of 2.3m. The second opening starts at x=4.1 and y=0.8 and has dimensions 0.5m x 0.5m.

project.viia_add_floor_openings(floor=floor, opening_list=[[0, 1.1, 1.8, 2.3], [3, 0.5, 0.8, 0.5]]

viia_add_legend_model_pictures(json_dir: Path, output_dir: Optional[Path] = None, legend_loc: str = 'upper right', fontsize: int = 7) → None

This function will add a legend to the existing figures in the model picture folder according to the legend_data json-file in the folder.

Input:

project (obj): Project object containing collections and of fem objects and project variables.
json_dir (Path): Path that contains the legend_data.json and model pictures.
output_dir (Path): Path that output the model pictures with legends. Default value None, using the work folder to store the pictures.
legend_loc (str): The legend location which is used for matplotlib. Default location is upper right.
fontsize (int): The font size of the legend used for matplotlib. Default value 7.

Output:

A json-file containing all picture color codes and names will be created.

viia_add_openings(opening_data_list: List)

Function to easily add openings to viia walls or sloped roofs, based on the measurements commonly specified in the inspection data. A list is expected that contains the data for the openings. Each row in this list represents a surface object to which openings need to be added. This function can be used for walls and sloped roofs. It is possible to supply the object to which openings need to be added, but also a simple name like ‘wall_5’ can be used.

Input:

project: VIIA project object containing collections of fem objects and project variables.
opening_data_list: List that contains the data for the openings. Each row represents a wall or sloped roof. All measurements should be provided in [m]

Example:

An example for an opening_data_list is:

openings = [['wall_1', [[0.6, 2.1, 0.2, 2.1], [0.3, 1.2, 0, 2.3], [0.3, 2.1, 0.2, 2.1]]],
           [wall_object, [[0.7, 2.4, 0, 2.1]], True],
           ['roof_1', [[0.3, 1.2, 0, 2.3], [0.3, 2.1, 0.2, 2.1]]]]

For walls: Expected input is a list of either a simple wall name or the wall object itself, opening data for that wall, and an optional boolean to flip the direction of the openings. In the opening data, each sublists represents an opening. The four values in this sublistrepresent distance to opening, width of the opening, height from bottom of wall to opening (borstwering) and height of the opening (hoogte kozijn). The distance to the opening is the distance to the edge of the wall for the first opening in the list, and the distance to the previous opening for each subsequent opening. The optional boolean can be used to flip the direction in which the openings are added to the wall.

For roofs: Similar to wall openings, each sublist in the opening data represents an opening. Again, the first two values are distance to opening and width of the opening. Third value is the height from the floor to the bottom of the opening, measured in absolute z-coordinates. The fourth value is again the height of the opening, but measured in the plane of the sloped roof. Also here it is possible to flip the direction.

viia_add_outer_leaf_wall_line_load(load_case: LoadCase, walls: List[Wall], is_foundation_cavity: bool, outer_leaf_volume: float = None, outer_leaf_mass_density: float = None)

This function adds line load of the outer leaf to the foundation wall.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
load_case (obj): Object reference of LoadCase to the load-case the load to be applied.
walls (list): List with object references of wall objects. The walls should be given based on the facade the foundation walls should be included.
is_foundation_cavity (bool): Consider the foundation walls cavity (True) or solid (False)
outer_leaf_volume (float): Total wall volume of the outer leaf walls. Use this parameter in case the outer walls have different shape than the inner leaf walls.
outer_leaf_mass_density (float): Mass density of the outer leaf walls. Use this parameter in case different material is used for the outer leaf.

Output:

Line loads on the foundation walls representing the weight of outer leaf.

viia_add_roof_openings(roof: Roof, opening_list: List[List], flip: bool = False)

Function to easily add openings to roofs, based on measurements commonly specified in inspection data. This function is used by viia_add_openings, if a roof object is detected. Openings are specified by supplying a list of four values; distance to opening, width of opening, height of opening above floor level and a height of the opening in the plane of the roof.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
roof (obj): Object reference of roof on which the opening(s) are applied.
opening_list (list): List that contains the data for the openings. All measurements should be given in [m].
flip (bool): Select to flip the direction in which the openings are added to the shape. Default value False.

Output:

Opening(s) are added to the roof.

Example:

An example of an opening list is: opening_list = [[0.3, 1.2, 0, 2.3], [0.3, 2.1, 0.2, 2.1]]

This creates two openings. The first opening is at a distance 0.3m from the edge of the roof (the order of the edges is determined by the local axes of the roof), and has dimensions width x height = 1.2m x 2.3m, and starts from the bottom edge of the roof. The second opening is located at a distance 0.3m from the previous opening, has dimensions width x height = 2.1m x 2.1m in the plane of the roof and starts from 0.2m above the bottom edge of the roof in absolute z coordinates.

viia_adjust_fstrips(fstrips: Optional[List[Fstrip]] = None, fstrip_directions: Optional[List[List[float]]] = None, fwalls: Optional[List[Wall]] = None) → None

Function to automatically adjust the geometry of the fstrip in relation to the adjacent strip. A list of fstrips should be provided, along with a list of corresponding directions. Multiple types of connections can be adjusted, for instance T-connections (in which the upper part of the “T” is continuous), perpendicular directions and corner connections with an arbitrary angle. More complex connections where multiple fstrips meet may raise errors, if no suitable adjustments can be made. The function ends with a check in which an error is raised if any overlaps still exist.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
fstrips (list of obj): List of object references of fstrips. Default value None, in which case all fstrips in the project are applied for the adjustment for the fstrips.
fstrip_directions (list of list of float): List of corresponding directions for each fstrip in fstrips. Should have same length as the number of fstrip objects. The directions are to be provided as list of 3 floats. Default value None, in which case it is tried to retrieve the direction from the supporting wall or foundation wall. If this fails an error is raised, in which case the directions should be provided manually.
fwalls (list of obj): List of wall objects that have been created for the foundation. These are used to connect to the foundation strips.

Output:

Function adjusts the geometry of the fstrips and connects them as requested for the implemented connection options. The function does not return anything.

viia_adjust_mass_of_surface(load, surface)

This function calculates the mass for the provided load, it calculates the increased or decreased self weight, based on the thickness of the surface. For this adjusted self weight, a new material is created, an existing (already updated) material is used or the material itself is updated.

Note

Negative loads are valid, resulting in a decrease of the self weight. This can be used to remove any previously applied loads.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
load (float): Value of the load to be added as mass, in [N/m2].
surface (obj): Object reference of surface shape to which the load is applied.

Output:

Updated material is applied to the surface.

viia_align_with_grid(shapes: List[Shapes], margin: float, x_grid: List[float], y_grid: List[float], z_grid: List[float], merge_shapegeometries: bool = False)

Function for aligning the nodes of shapes to a given grid. If this results in a out of plane displacement of a surface, the user will be notified.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
shapes (list of obj): List of object references of the shapes to be aligned.
margin (float): Distance between the nodes and the level to determine if the node needs to be moved, in [m].
x_grid (list with floats): List with grid in x-direction, in [m].
y_grid (list with floats): List with grid in y-direction, in [m].
z_grid (list with floats): List with grid in z-direction, in [m].
merge_shapegeometries (bool): Indicates if the shapegeometries should be merged after aligning them. When multiple shapes are aligned this boolean should only be True for the last function call out of speed reasons. Default value False.

Output:

The nodes within the set levels is translated in the given direction.

viia_analysis(analysis_nr: str, run: bool = False, signals: Optional[Union[List[str], str]] = None, directions: Optional[Union[List[str], str]] = None, nmodes: Optional[int] = None, ac_pivots: Optional[str] = None, combox: str = 'server', iteration_method_requested: str = 'newton-raphson', output_1c: Optional[bool] = False, nr_time_steps: Optional[int] = None, suppress_analysis: Optional[bool] = False, mod_param: Optional[List[List[Union[str, List]]]] = None, save_mode_pictures: Optional[int] = 5, load_datfile: bool = True, geo_output: bool = True)

This function will create the analysis required, and if selected runs the analysis directly when running in DIANA. In that case the default output items are handled and created in the analysis folder.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
analysis_nr (str): Current analysis referencing the numbers in the viiaStatus. For example ‘A1’.
run (bool): Select if the analysis should be performed directly, also result handling will be performed. The default value is set to ‘False’, indicating that the analysis and result handling is not performed while running the mainscript.
signals (list of str): A list of the signals can be provided for the signals of which the analysis should be prepared. If the default signals need to be applied select ‘Default’. The default value of the argument is None, indicating no signals to be applied. Apply random selection of signals for example: [‘S1’, ‘S6’], apply VIIA naming convention for signals (in viiaStatus).
directions (list of str): A list of the directions can be provided for the directions of which the analysis should be prepared. If the default directions need to be applied select ‘Default’. The default value of the argument is None, indicating no directions to be applied. Apply random selection of directions for example: [‘X_neg’, ‘Y_neg’], apply VIIA naming convention for directions (in viiaStatus).
nmodes (int): For Eigen value analysis (analysis type ‘EIGEN’, analysis_nr ‘A3’ or ‘A7’) - nmodes refer to the number of mode shapes to get in your analysis. For Modal Response Spectrum analysis (analysis type ‘MRS’, analysis_nr ‘A5’) - nmodes refer to the maximum of x- and y- direction mode shape at which cumulative modal participation factor reaches 70%. If eigen value analysis (A3 or A7) results are present in the workfolder then script will search for nmodes automatically (if 70% value is not reached then a warning is printed instead). If eigenvalue analysis are not present in the workfolder then nmodes should be specified manually.
ac_pivots (str): Name of method of obtaining arc-length control pivots or a sequence of node numbers in string format.
combox (str): Set the location where to run the dcf if the calculation is not performed directly. The dcf is by default prepared for running on the server (adding the initialisation of the filos file and input and for flexbase will add the user subroutine dll location).
iteration_method_requested (str): The iteration method selected for the time-steps execute, the default value is ‘newton-raphson’. Other options are ‘secant’ and ‘linear-stiffness’.
output_1c (bool): Default False. If true the 1c output block will be returned. Only applicable for NLTH analysis.
nr_time_steps (int): Overrule the number of time-steps to be used in the NLTH analysis. Default value None, time-steps are determined based on the length of the signal. Only applicable for NLTH analysis.
suppress_analysis (bool): If set to True, this will stop the creation of analysis and dcf files and function will return an analysis that can be adjusted. After adjustment, it will be possible to create analysis and write dcf files.
mod_param (List[List[Union(str, List)]]): a list of parameters which will be used to modify analysis object.
save_mode_pictures (int): This refers to number of modes, for which the result items displacement DispXYZ and rotation RotXYZ is plotted for the entire structure. Default value is set to 5 based on the template for Appendix C2.
load_datfile (bool): Select if the dat-file for DIANA should be loaded. This is not required if it was already loaded previously and no changes to the model have been made in the meantime. Default value is True.
geo_output (bool): This allows the user to choose if the geo output needs to be created (only when the analysis and result handling is selected to be executed). Default value is True.

Output:

The required analysis is prepared in a specific folder.
If selected the analysis is directly performed and results are handled.

viia_analysis_diana_gui_files(analysis: Analysis)

When running an analysis directly from script in the DIANA GUI, the calculation files are located in the working directory. For result handling, the files need to be moved to the appropriate analysis folder. This function performs the moving and deleting of files.

When running a calculation in DIANA it creates a result file (dnb-file), a filos file (ff-file) and out files (out-files). The filos file is not needed anymore and is removed with this function. The result and out files are moved to the current analysis folder (project.current_analysis_folder). There functions for result handling will look for the results.

Note

After running a calculation in DIANA the result file is loaded in DIANA GUI automatically. When directly running this function, the file is locked and a copy is placed in the analysis folder. The result file in working directory can be removed after closing DIANA. But it is better to run picture scripts etc. directly after running the calculation and then remove the analysis in the script (the file is then unlocked).

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
analysis (obj): Object reference of ‘Analysis’ class. The analysis which will be performed. Default value is ‘None’. In case of SCIA calculations no analysis is needed. In case of DIANA calculations, the analysis it is required to provide the analysis. Alternative (str): Name of the analysis to be performed (there should be an object with that analysis).

Output:

Files are moved and deleted.
Notifications are given of errors.
Returns the out-file.

viia_append_envelope_requests_geo_abaqus(json_path: Path, pile_displacement_requets: bool = False)

Appends json file that is an input for abaqus envelope script with the data about the section forces of the foundation strips.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
json_path (Path): Path object of the json to be appended location.

viia_auto_hinges(override_hinges: Optional[List[List[str]]] = None, disable_nodes: Optional[List[Union[Node, List[float, int]]]] = None, disable_hinges: Optional[List[List[str]]] = None, collection: Optional[List[Union[Beam, Column]]] = None)

This function generates hinges for all columns and beams in project.collections. It checks if the members are continuous, if true it will create a fixed connection. This function only works on columns and beams.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
override_hinges (list of list of str): List of exceptions for the automatic algorithm. Default value is None, no overrides applied. e.g. [[‘source_shape_name’, ‘target_shape_name’, ‘hingetype’], [‘N2-BALKEN-STAAL-S235-HEA140-5’,’N2-BALKEN-STAAL-S235-SHS80x6-1’, ‘H_RRF’]]
disable_nodes (list of (nodes or lists of floats/ints)): List of nodes to disable auto hinge generation. The input for this argument can also be provided as a list of coordinates.
disable_hinges (list of list of str): List of list of source-target pairs for which the hinges need to be omitted. The order in which the elements are specified is not important. eg. [[‘N2-BALKEN-STAAL-S235-HEA140-5’,’N2-BALKEN-STAAL-S235-SHS80x6-1’]]
collection (list of shapes): A list of object references of Column or Beam class which are checked to apply hinges on. Default value is None, checking all shapes in the project.

Output:

Returns list of created hinges.

viia_auto_interfaces(is_linear: bool = False, override_connections: List[List[str]] = None, disable_connections: List[List[str]] = None, disable_interfaces: List[str] = None, replace_interfaces: Dict[str, Union[str, Any]] = None)

This function generates interfaces in the model based on the BoD. It creates interfaces only between connecting shapes. The function uses the ‘viia_auto_connections_library.yaml’ in order to determine which connection type is to be applied. It does not create interfaces (hinges) between beams, therefore use the viia_auto_hinge function.

Currently implemented interfaces: ‘D2.01’, ‘D2.01a’, ‘D2.01b’, ‘D2.03’, ‘D2.07’, ‘D2.11’, ‘D2.14’ and ‘D4.02’.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
is_linear (bool): Boolean to apply linear or non-linear material properties for the interfaces. Default value is False, applying non-linear behaviour.
override_connections (list of list of str): List of lists of shape pairs to override automatic implementation. Input order for shapes is important and should follow definitions required for viia_create_connection(). e.g. [[‘source_shape_name’, ‘target_shape_name’, ‘detail’, kwargs(opt)], [‘N0-WANDEN-MW-KLEI<1945-100-2’,’N1-VLOEREN-LIN-HBV-PLANKEN-0.022-0.05-0.15-0.65-0’,’NOCON-L’], {‘flip’:True}]. Default value is None.
disable_connections (list of list of str): List of lists of shape pairs to disable automatic implementation. Input order for shapes is not important. Default value is None. e.g. [[‘source_shape_name’, ‘target_shape_name’], [‘N0-WANDEN-MW-KLEI<1945-100-2’,’N1-VLOEREN-LIN-HBV-PLANKEN-0.022-0.05-0.15-0.65-0’]].
disable_interfaces (list of str): List of interfaces to disable, e.g. [‘D2.01’, ‘D2.07’]. Default value is None. In that case, the following list is used: [‘D2.03’, ‘D2.07’, ‘D2.11’, ‘D2.14’, ‘D4.02’, ‘D2.01b’] This list is based on the current modelling strategy, and makes sure only the basic interfaces are applied. If no interfaces should be disabled, supply the following input value: [] .
replace_interfaces (dict): Dictionary of old to new interface mappings. Default value is None. e.g. {‘D2.01’: [‘D2.01’, {‘is_linear’: True}], ‘D2.07’: ‘D2.01’}.

viia_base_shear(analysis: Analysis, base_shear_tb_file: List[Union[Path, str]] = None, geo_postprocessed_data_json_file_abaqus: Union[Path, str] = None)

This function calculates the base shear from a DIANA analysis or ABAQUS geo post-processing for an object with strip foundation, or pile foundation or mixed foundations.

Input:

project (obj): Project object containing collections and of fem objects and project variables.
base_shear_tb_file(list): List of output .tb files for calculating the base shear from DIANA.
geo_postprocessed_data_json_file_abaqus(string or Path): Path or string of path of output .json files for geo postprocessing from ABAQUS.
analysis (obj): Object reference of the analysis of which the base shear should be calculated.

Output:

A figure with the base shear in time-history is created and saved in the current analysis folder.
A json file with calculated base shear in time-history is created and saved in the current analysis folder.

viia_change_linemass()

Conversion function to changes line-mass elements from enhanced trusses into 3D beams. Line masses should be modelled in DIANA. Properties are assigned to the elements in the model. No updates in PY memory.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

The line-masses are updated in DIANA

viia_change_signal(new_signal: str, nr_time_steps: Optional[int] = None)

This function enables to switch the signal in the model. Signals to be applied can be signal 1 to 11, although signal 8-11 should be provided first as input. Function works on base-signals and normal signals, depending on the available geometry load combinations.

The following items are updated:

The material properties of the soil are adjusted (Rayleigh damping factors).
The time dependent factors for the load with the seismic signals is updated to the new signal.
The number of time-steps in the analysis are adjusted appropriately.
The requested output-items for time-steps is adjusted appropriately.
In the current analysis folder the adjusted dat- and dcf-files are updated.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
new_signal (str): Name of the signal to be applied, for example: ‘S2’.
nr_time_steps (int): Overrule the number of time-steps to be used in the NLTH analysis. Default value None, time-steps are determined based on the length of the signal.

Output:

The signal and dependent properties are updated in the model.
Notification and logging of changes.

viia_check_inner_wall() → bool

This function will check if a wall is an inner wall. This is assessed in two steps:

First check if the start node of any line of the wall is inside the surface of the floor, or if the coordinate of middle of the top line of the wall is inside the floor surface when both top nodes of the wall are on the contour of the floor. If true then it is an inner wall, if not then it goes to step 2.
Second check if the wall has upper floors on its both sides, if true then it is an inner wall, otherwise it is not an inner wall.

Note

Before applying this function make sure to connect all shapes first.

Input:

wall (obj): Object reference of Wall object.

Output:

Returns a boolean whether the wall is an inner wall or not.

viia_check_layers() → True

This function checks if the layers comply. It checks if the required layers are present, and if no layers are missing between others.

Input:

No input required.

Output:

Returns True if the layers in the model comply.
Raises error if any layer is missing.

viia_check_materialname_present(material_name) → Union[None, str]

This function checks if the material is present in the material-database of VIIA.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
material_name (str): Name of the material that is looked up in the material database.

Output:

Returns the name of the material group to which the looked up material belongs. If not found ‘None’ will be returned.

viia_check_mesh(min_angle: float = 15, max_angle: float = 165, max_skewness: float = 45, max_aspect_ratio: float = 5, output_folder: Optional[Path] = None) → Optional[Path]

This function checks the mesh of the model. The default requirements for VIIA are included in the ViiaSettings module. The function currently checks for the following items:

Check if the angles of the mesh-element are larger than the minimum angle requirement (VIIA default 15 degrees).
Check if the angles of the mesh-element are smaller than the maximum angle requirement (VIIA default 165 degrees).
Check if the skewness of the mesh-element is smaller than the maximum skewness requirement (VIIA default 45 degrees).
Check if the aspect-ratio of the mesh-element is smaller than the maximum aspect-ratio requirement (VIIA default is 5).

Note

The model must be meshed.

Input:

project (obj): Project object containing collections and of fem objects and project variables.
min_angle (float): Checking bound for smallest allowable mesh-element angle, in [deg]. Default value set in the ViiaSettings module.
max_angle (float): Checking bound for largest allowable mesh-element angle, in [deg]. Default value set in the ViiaSettings module.
max_skewness (float): Checking bound for the maximum allowed skewness of the mesh-element angle, in [deg]. Default value set in the ViiaSettings module.
max_aspect_ratio (float): Checking bound for the maximum allowed aspect-ratio of the mesh-element angle, in [-]. Default value set in the ViiaSettings module.
output_folder (Path): Optional input for location where to create the report. Default value is None, indicating the default location is used. In normal production objects do not change this!

Output:

Returns the path of the folder with the mesh check output files. These include the mesh check report in pdf, json-file of the model and the model summary in pdf.
In case there is no mesh the function is not executed and a warning is provided. Script continues.
The report offers insights into the mesh setup. It displays the count of mesh nodes and elements and a list of the element-types used. Alongside general information, the report includes graphs depicting distributions.
All mesh-elements are checked for compliance to the provided boundaries.
In case of not compliance a warning is raised indicating the model is not complying to the VIIA requirements. The user can proceed, but should review the locations of the exceedances. In most cases the mesh can be improved by applying a mesh-seeding or simplify geometry. Discuss with your Lead Engineer.

viia_collect_pile_reactions(pile_output_file: Path, analysis: Analysis, signal: Optional[str] = None) → Path

This function collects the pile forces from the DIANA output file, creates graphs per pile with the forces over time, and it creates a json-file with the collect information that can be used for reporting.

Input:

project (obj): Project object containing collections and of fem objects and project variables.
pile_output_file (Path): Path to the OUTPUT_5B tb-file from DIANA NLTH analysis.
analysis (obj): Object reference of the NLTH analysis.
signal (str): String representing the signal, can be S1 to S11.

Output:

Returns the folder with the created results for the piles.

viia_collect_reference_models()

Function to collect the reference object models from MYVIIA and store for further assessment of failure mechanisms.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

The selected reference objects in MYVIIA are collected and stored in the project instance.

viia_collect_reference_walls_data(failure_mechanism: str, ref_models: Dict = None) → Tuple[Union[Path, List[RefWallIP], List[RefWallOOP], List[Dict]], List[Dict[str, Union[str, float]]]]

Function to collect the data from all walls in all referenced objects and store for further assessment of failure mechanisms.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
failure_mechanism (str): The type of report required. Possible options are ‘IP’ and ‘OOP’.
ref_models (dict): Dictionary with reference models that need to be considered. Default is None, then the reference models binded to the project are used.

Output:

If save_xls is True. Returns an excel-sheet with detailed data of the walls in the reference objects
Else a list of instance of collected walls and a list of dictionary with the data are returned.

viia_compare_shape_name(shape_name_1: str, shape_name_2: str, exclude: Optional[List[str]] = None) → bool

This function can be used to compare the name of the shapes. Select parts of the name to exclude in the comparison. The function has been designed for the situation that the shapes are filtered between A10/A13 and A12/A15, but the density can change between them.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
shape_name_1, shape_name_2 (str): The name of the shape to be used in the comparison.
exclude (list of str): Excluding parts for the comparison. Default value is None, using [‘DENSIT’], excluding any parts with adjusted density name-parts.

Output:

Returns boolean if the shape-names are evaluated the same.

viia_connect_all_shapes(list_of_shapes: Union[str, List[Shapes]] = 'ALL')

This functions connects all surface- and line-shapes with all volume-, surface-, line- and point-shapes. First, all lines and nodes in the project will be merged. For surfaces, it finds lines which completly on the surface and add those lines to the surface as internal line. It also finds lines which are completly on the contour of a surface and add the points of the line to the contour. Besides it find nodes which are on the surface and add those as internal points or add them to the contour. For lines, it finds nodes which are on the line and add those node as internal point.

Note

Function will only run in PY-editor, or if model is not created.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
list_of_shapes (list of Obj): List with object references of shapes that will be checked if they are connecting to the requested shape. Default value is ‘ALL’, indicating that all shapes present will be checked.

Output:

No more double Line(ShapeGeometries) and Node(ShapeGeometries) objects.
All shapes are connected.

viia_connect_cavity_walls(cavity_wall_1: Wall, cavity_wall_2: Wall, adjust_second: bool = True)

This function connects two vertical and rectangular (cavity) walls by adjusting the contours of both walls such that the intersection line of the wall planes is included in both wall contours. If parallel walls are given, their contours remain unchanged.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
cavity_wall_1 (obj): Wall to be connected to cavity_wall_2.
cavity_wall_2 (obj): Wall to be connected to cavity_wall_1.
adjust_second (bool): If is true cavity_wall_2 will also be changed. If false cavity_wall_2 will remain unchanged, this can be needed at specific T-sections.

Output:

The (cavity) walls are connected, nothing is returned.

viia_connect_shape(shape: Shapes)

This functions connects the shape with all shapes in the model. For surfaces, it finds lines which completely on the surface and add those lines to the surface as internal line. It also finds lines which are completely on the contour of a surface and add the points of the line to the contour. Besides it find nodes which are on the surface and add those as internal points or add them to the contour.

For lines, it finds nodes which are on the line and add those node as internal point.

Note

Function does not run in DIANA if model is created.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
shape (obj): Object reference of shape which should be connected.

Output:

All surface-shapes are updated with coordinates of other shapes which are on the contour of the surface-shape.
All surface-shapes are updated with shape-geometry lines of other shapes, which are in the plane of the surface-shape, as internal lines.
All surface-shapes are updated with shape-geometry nodes of other shapes, which are in the plane of the surface-shape, as internal points.

viia_connections_get_mappings(print_to_screen: bool = False)

This function can be used to print a mapping corresponding between geometry pairs and unique ID of the connection. Function generates mappings for all connections in project.collections.connections that were named using the unique ID function.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
print_to_screen (bool, optional): bool specified if the mapping list should be printed to screen. Default value False.

Output:

Returns a dictionary. A dictionary with frozen sets of shape pairs in the connection as keys and dictionary as source, target names and unique IDs as values.

viia_convergence_graph(file: Union[Path, str], criterion: str = 'energy', signal: Optional[str] = None, show: bool = True, plasticity: bool = False, analysis: Optional[Union[str, Analysis]] = None) → Path

Function generates the convergence graph based on the output file of a DIANA analysis.

Input:

project (obj): Project object containing collections and of fem objects and project variables.
file (path or str): File name and location as single string of the out-file (DIANA) or msg-file (ABAQUS).
criterion (str): Select the criterion to plot the convergence for. For DIANA, choose between energy, displacement or force convergence criterium. For ABAQUS, choose between force or moment convergence criterium. For ABAQUS, a displacement convergence graph is also added when force is chosen, a rotation convergence graph is added for moment. Only one criterion can be selected. Default value is energy.
signal (str): Optional input to include signal in title. Can be S1-S11.
show (bool): Switch to indicate if the pop-up screen of the graph should appear. Default value is True.
plasticity (bool): Select to add another graph for the plasticity behaviour. Default value is False, in which case only cracking behaviour is plotted.
analysis (Obj): Optional input for the object reference of the analysis that is performed. Default value is None. Also, the name of the analysis can be provided as string (in that case it is only used in the title of the plot).

Output:

Returns the path of the created image with the convergence graph and supporting graphs. The image is saved in the current analysis folder.

viia_convert_all_columns_to_walls(reference_width: float = 1.0) → List[Wall]

This function converts all columns with a width larger than the provided dimension to walls, with the same properties. The width of the wall is considered the height of the cross-section (local z-axis), the thickness is considered the width of the cross-section (local y-axis).

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
reference_width (float): Minimum height of the cross-section of the column that will be converted to wall, in [m]. Default value is 1m.

Output:

All columns with a cross-sectional height (z-axis) larger than the reference width, will be converted to walls.
Naming convention according VIIA project is applied.
Returns list of all newly created walls.

viia_convert_imposed_loads_to_self_weight()

This function will convert any imposed loads created with the ‘viia_create_loads’ function to mass as part of the self weight of the surface shape. The ‘psi’ and ‘phi2’ factors will be applied.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

The loads are converted to masses and incorporated in the density of the material object. The material applied will be updated.
The imposed loads are removed from the model. The data to recreate the imposed load after converting to Only saved to the variable in the self weight is stored in the shape meta-data.
The load-combination for imposed loads is removed.

viia_convert_self_weight_to_imposed_loads()

This function will re-convert any imposed loads that was converted by viia_convert_imposed_loads_to_self_weight. The part of the self weight for the imposed loads is removed from the density material of the surface shape. The ‘psi’ and ‘phi2’ factors will be removed.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

The masses incorporated in the density of the material object are re-converted to loads. The material applied will be updated.
The imposed loads again created in the model and project.collections. The information used should be stored in the meta-data of the shape.
The load-combination for imposed loads is created.

viia_create_all_boundary_springs_for_static_analysis(spring_stiffness: float = 20, exclude_shapes: List[Lines] = None) → List[BoundarySpring]

Creates boundary springs at the ends of Beams and Columns. These supports are needed to prevent rotation around the longitudinal axis of those shapes during static calculation. Note the data model TORSTI only works during transient analyses in DIANA.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
spring_stiffness (float): Rotational stiffness, in [Nm/rad] for the boundary springs. Default value 20 Nm/rad.
exclude_shapes (list of obj): List of object references for line-shapes (beams and columns) to be excluded from the boundary spring application.

Output:

List of all the created boundary springs.

viia_create_all_datas()

This function will set the data properties for all the shapes and connections, based on the VIIA convention. For all soil shapes the data is set for ‘GROND’ and interfaces ‘INTERFACE’. For the rest of the shapes and connections the number of integration points over the thickness is set to the number in viiaSettings (depending on linear or non-linear material behaviour). Point-shapes, no-connections and tyings are excluded in this function. Also, shapes or connections that already have a data assigned are not updated.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

All data attributes of shapes and connections are set. Except if the shape or connection has sub-shapes or already has a data set.

viia_create_all_lintels(lintel_material: str, lintel_type: str, collection: Union[str, List[Union[Wall, str]]] = 'All', support_length: float = 0.1, lintel_slab: bool = True) → List[Lintel]

This function creates a lintel above all wall openings in the model.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
lintel_material (str): The material of the lintel, all VIIA materials available.
lintel_type (str): The profile of the lintel, all profiles available as for beams. Use VIIA naming convention.
collection (list of obj): List of object references of walls for which all the openings will get a lintel on top of the opening with the provided material and geometry. Alternatively the list can be provided as list of names of the walls. Also input of the name of the layer can be given, in which all the lintels for the openings of the walls in the layer are created. Default value is ‘All’, which will apply lintels for all openings in the model.
support_length (float): The length of the support, in [m]. This is the distance from the corner of the opening to the end of the lintel. Default value is 0.1.
lintel_slab (bool): By default is True, which means dummy plates will be created between outer leaf and inner leaf on the openings of a cavity wall. If False, lintel beams will be created on both inner and outer leaves.

Output:

Lintels are created for the openings in the provided collection. All lintels in this function have the same material and geometry.

viia_create_analysis(analysis_nr: str, direction: Optional[str] = None, nmodes: Optional[int] = None, loadnr: Optional[int] = None, ac_pivots: Optional[str] = None, number_eigenmodes: int = 10, modal_pushover_flag: bool = True, iteration_method_requested: str = 'secant', output_1c: bool = False, nr_time_steps: Optional[int] = None) → Analysis

Function to add a default analysis to the model in DIANA, see viiapackage documentation howto_dcf_settings. The name of the analysis that is created depends on the state of the model. This can be fixed base, flex base, soilblock or soilcolumn.

Note

Always check your dcf-file prior to calculation.

Note

To increase speed of the calculation, check the requested output (writing output takes time).

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
analysis_nr (str): Current analysis referencing the numbers for different analyses. For example ‘A1’.
direction (str): String of the direction can be provided for the direction of which the analysis should be created. The default value of the argument is None, indicating no directions to be applied.
nmodes (int): Number of eigenmodes to take into account in the analysis. This value is only used in eigenvalue analysis.
loadnr (int): The associated ID (as integer) of the LoadCombination instance with the name corresponding to the NLPO load-cases, if available.
ac_pivots (str): Name of method of obtaining arc length control pivots or a sequence of node numbers in string format.
number_eigenmodes (int): Only used when the modal pushover analysis is set up. This is the number of modes set for the eigenvalue analysis executed before the modal pushover analysis, the default value is 10. When the dominate mode is after the first 10 modes, this should be adjusted accordingly.
modal_pushover_flag (bool): If this argument is set to True, the eigenvalue analysis will executed before modal NLPO analysis, otherwise eigenvalue analysis is not set up for uniform NLPO analysis. The default value is True.
iteration_method_requested (str): The iteration method selected for the time-steps execute, the default value is ‘secant’. Other options are ‘newton-raphson’, ‘linear-stiffness’ and ‘constant stiffness’.
output_1c (bool): Default False. If true the 1c output block will be returned.
nr_time_steps (int): Overrule the number of time-steps to be used in the NLTH analysis. Default value None, time-steps are determined based on the length of the signal.

Output:

Requested analysis-type is created in DIANA.

viia_create_beam(name: Union[str, Layer], material: str, geometry: str, points: List[List[Union[float, str, Shapes, Level]]], is_truss: bool = False, is_roof_beam: bool = False) → Beam

VIIA function to create a beam shape based on layer, material, geometry and contour points. The beam can be optionally turned into a truss element.

Warning

In this release a string containing the full name is still accepted as input for name. In future releases this functionality will be deprecated. Enter a layer object instead.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
name (str or Layer): Name of the layer as a string, or the Layer object itself, to which the newly created column should be added. Full name of shape is also accepted, not applying auto naming function, this will be removed in future releases.
material (str): Name of the material of the beam shape to be created, complying VIIA naming convention.
geometry (str): Name of the geometry of the beam shape to be created, complying VIIA naming convention.
points (list of list of floats and shapes): The start and end point of the beam shape. Each point is a list of 3 floats or 2 floats and 1 shape. If 3 floats are given, the unmodified point is used. If 2 floats and 1 shape is given, the unknown coordinate at the index of the shape is calculated by projection on this shape. Shapes can be inputted as objects or strings e.g. [[19.2, 6, “roof_1”], [0, 1, 4]] or [[19.2, roof_1, 15], [0, 1, 4]]. The z-coordinate can also be provided as level object, or name of the level.
is_truss (bool): Select to transform the beam object into a truss object. Default value is False.
is_roof_beam (bool): Select to indicate if the beam is part of the roof structure (and is plotted in the roof plot also in case of no roof sheeting). Default value is False.

Output:

Returns the created beam object reference.
The beam is added to the project and to the layer.

viia_create_beams_on_grid(layer: str, beam_list: List[List[Union[str, int]]], grid: Optional[Union[Grid, int, str]] = None, is_truss: bool = False) → List[Beam]

This function is used to set up the beams for a specific layer, making use of a grid system. A beam list is given as input, in which each row represents a beam. Each beam is in turn represented by a list of five values; starting point, end point, z-coordinates, material and cross-section. The points to place the beams should be given in grid notation, for instance ‘A3’. The beams can be optionally turned into truss elements.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
layer (str): String specifying the layer, conform VIIA naming convention. For example: ‘N0’.
beam_list (list): List containing the information of the individual beams, for example: [[‘D1’, ‘D9’, [2.5, 3.5], ‘HOUT’, ‘100x100’], [‘D9’, ‘L9’, 2.5, ‘HOUT’, ‘100x100’], [[0, 5.3], [7.5, 5.3], 4.6, ‘HOUT’, ‘100x100’] This will create three timber beams with a cross-section 100mm x 100mm. The first beam is created from grid point D1 at an elevation of 2.5 m to D9 at an elevation of 3.5. The second beam is created from grid point D9 to L9 at an elevation of 2.5 m. The third beam is created at coordinates [0, 5.3] and [7.5, 5.3] at an elevation of 4.6 m. Note that to create an inclined beam, the heights must be given as a list
grid (Grid, int, str): Optional object, id or name of the grid to use. By default, the first grid in the collection is used.
is_truss (bool): Select to transform the beam object into a truss object. Default value is False.

Output:

Each beam described in the beam list is added to the project and the relevant collections.
A list containing all beam objects is returned.

Example:

>>> project.viia_create_beams_on_grid(
        layer='N0',
        beam_list=[['D1', 'D9', 3.0, 'MW-KLEI<1945', 210], ['D9', 'L9', [2.0, 3.0], 'MW-KLEI<1945', 210],
        [[0, 5.3], [7.5, 5.3], 4.6, 'HOUT', '100x100']])

viia_create_beams_on_grid_in_shape(layer: Union[str, Layer], grid: Union[Grid, int, str], gridlines: List[Union[str, int]], shape: Surfaces, material: str, geometry: str, is_truss: bool = False, is_roof_beam: bool = False) → List[Beam]

This function can be used to create beams that lie inside a surface shape using the grids. The best use of this function is for purlins and rafters, but can also be used for beams supporting a floor. Beams will be created on all the given gridlines, and they will be cut by the contour of the given surface shape. The beams can be optionally turned into truss elements.

Note

Currently, this function only works for gridlines that are parallel to either the x-axis or the y-axis.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
layer (obj): Layer object in which the beams are located. Alternative (str): String representing the layer name, conforming to VIIA naming convention. E.g. ‘N0’.
grid (obj): Grid object that the beams are plotted on. Alternative (int): ID of the grid object. Alternative (str): Name of the grid object.
gridlines (list of str or int): List containing the names of the gridlines on which the beams are plotted. The entries in the list can be either strings or integers.
shape (obj): The surface shape that the beams are created in.
material (str): Name of the material of the beam shape to be created, complying VIIA naming convention.
geometry (str): Name of the geometry of the beam shape to be created, complying VIIA naming convention.
is_roof_beam (bool): Select to indicate if the beam is part of the roof structure (and is plotted in the roof plot also in case of no roof sheeting). Default value is False.

Output:

Each beam described in the beam list is added to the project and the relevant collections.
A list containing all beam objects is returned.

viia_create_boundary_springs_for_static_analysis(shapes: List[Union[Beam, Column]], spring_stiffness: float = 20) → List[BoundarySpring]

Creates boundary springs at the ends of the given shapes (columns and beams). These supports are needed to prevent rotation around the longitudinal axis of those shapes during static calculation. Note the data model TORSTI only works during transient analyses in DIANA.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
shapes (list of objects): Shapes for which the boundary springs should be made.
spring_stiffness (float): Stiffness [Nm/rad] for the boundary springs.

Output:

Returns list of all the created boundary springs.

viia_create_cavity_wall_tie(inner_leaf: Wall, outer_leaf: Wall, point_inner: Union[List[float], Node], point_outer: Union[List[float], Node], material: Optional[Material] = None)

Function to create a cavity wall tie between two walls. The two points that are given are added as internal points to their corresponding Wall object, and a spring is constructed between these two points. By default, the VIIA convention for cavity wall tie material is used.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
layer (str, Layer): String or Layer object to which the tie should be added.
inner_leaf (Wall): Object reference to the inner leaf wall.
outer_leaf (Wall): Object reference to the outer leaf wall.
point_inner (List, Node): Coordinate or Node on inner leaf.
point_outer (List, Node): Coordinate or Node on outer leaf.
material (Material): Optional object reference to a material for the tie.

Output:

Spring object describing the cavity wall tie

viia_create_cavity_wall_ties(inner_leaf: Wall, outer_leaf: Wall, edge_distance: float = 0.25, ties_per_m2: Optional[float] = None, wall_tie_distance: Optional[float] = None, snap_to_openings: bool = True, snap_to_contour: bool = True, offset_base: float = 0, offset_vertical: float = 0, lines_to_snap: Optional[List[Line]] = None)

Function to create cavity wall ties between two walls. Function generates a grid of evenly distributed points over the inner leaf. Points in openings are disregarded. Points close to opening lines are snapped by default if they are within the given edge distance.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
inner_leaf (Wall): Wall object for the inner leaf.
outer_leaf (Wall): Wall object for the outer leaf.
edge_distance (float): Distance from which to snap points to openings or contour, if desired. Default is 0.25m
ties_per_m2 (float): Number of ties per m2. Default value is 4 ties/m2.
wall_tie_distance (float): Distance between ties, in [m].
snap_to_openings (bool): Toggle for snapping to opening lines.
snap_to_contour (bool): Toggle for snapping to contour lines.
offset_base (float): Optional offset of the ties in the direction of the base of the wall in [m]. Default value 0.
offset_vertical (float): Optional offset of the ties in the vertical direction in [m]. Default value 0.
lines_to_snap (list): List of Line object to snap the ties nearby.

Output:

list of wall tie objects, created in the Spring class

viia_create_cavity_wall_ties_from_list(cavity_wall_list: List[Union[List[Union[str, Wall, dict]], str, Wall]], **kwargs)

This function creates cavity walls for a list of walls. Properties for each cavity wall are specified by an accompanying dictionary of keyword arguments. Cavity wall pairs of which their origin walls are connected at either ends, are automatically connected. Given walls should not cross one another and only connect at their ends. Among the given walls no more than two walls should connect in the same point.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
cavity_wall_list (list of lists of a string or object and dictionary): A list of lists containing data about the walls for which cavity walls are to be created. Examples of input can be found below.
cavity (float): Cavity distance between the walls.
outer_wall_thickness (float): Optional thickness of the outer wall in [m]. If nothing is provided, thickness will be equal to the inner leaf.
outer_wall_material (str): Optional material of the outer wall. If nothing is provided, material will be equal to the inner leaf.
flip (bool): Toggle to flip the direction of creation of the wall. By default the outer wall is created in the direction of the normal vector of the wall.
no_ties (bool): Toggle to prevent creation of cavity wall ties. Default is False.
connect_outer_leafs (bool): Toggle to connect edges of outer leafs. Default is True.
dummy_plates (bool): Toggle to create dummy plates under the walls. Default is True.
edge_distance (float): Distance from which to snap points to openings or contour, if desired. Default is 0.25m
ties_per_m2 (float): Number of ties per m2. Default value is 4 ties/m2.
wall_tie_distance (float): Distance between ties, in [m]. Default is 0.5m.
snap_to_openings (bool): Toggle for snapping of cavity ties to opening lines. Default is True.
snap_to_contour (bool): Toggle for snapping of cavity ties to contour lines. Default is True.
offset_base (float): Optional offset of the ties in the direction of the base of the wall in [m]. Default is 0
offset_vertical (float): Optional offset of the ties in the vertical direction in [m]. Default is 0.
complete_output (bool): Optional toggle to return all newly created shapes. Default is False.
lines_to_snap (list): List of Line object to snap the ties nearby

Output:

If complete_output argument is False (default), a list of the newly created outer leaf objects is returned. If complete_output is set to True, three lists are returned. First list has the outer leaf objects, second list the wall tie objects, and third list the dummy plates.

Examples:

Different types of input can be given to this function. The basic input is as follows:

project.viia_create_cavity_wall_ties_from_list(
    cavity_wall_list=['wall_1', 'wall_2', 'wall_3' .. etc.], cavity=0.1)

This will create outer leafs, cavity wall ties and dummy plates for all the walls in the cavity wall list, with a cavity of 0.1m. The rest of the arguments will have their default value.

It is also possible to provide different arguments to a specific wall. In this case a list should be provided that includes the wall and a dictionary of keyword arguments, like so:

project.viia_create_cavity_wall_ties_from_list(
    cavity_wall_list=['wall_1', ['wall_2', {'cavity': 0.2}], 'wall_3' .. etc.], cavity=0.1)

This will create all outer leafs, cavity wall ties and dummy plates with a cavity of 0.1m, except for wall with id 2 the cavity will be 0.2m. Note that this can be done for all keyword arguments described in the input parameters above. Input may therefore also look something like this:

project.viia_create_cavity_wall_ties_from_list(
    cavity_wall_list=[
        ['wall_1', {'cavity': 0.18, 'wall_tie_distance': 0.7, 'outer_wall_thickness': 0.15}],
        ['wall_2', {'flip': True, 'no_ties': True}],
        'wall_3', 'wall_4',
        ['wall_5', {'dummy_plates': True, 'edge_distance': 0.3, 'offset_vertical': 0.1, 'flip': True}]
    ],
    cavity = 0.3,
    dummy_plates=False,
    offset_base=0.25,
    snap_to_contour=False)

viia_create_collar_ties_on_grid(layer: Union[str, Layer], grid: Union[Grid, int, str], gridlines: List[Union[str, int]], shapes: List[Shapes], beam_height: Union[float, Level, str], material: str, geometry: str, floor_level: Optional[Union[float, Level, str]] = None, is_truss: bool = True, is_roof_beam: bool = False) → List[Beam]

This function can be used to created collar ties between two roof shapes using the grids. Beams will be created on all the given gridlines, and they will be cut by the two roof plates. The beams can be optionally turned into truss elements.

Note

Currently, this function only works for gridlines that are parallel to either the x-axis or the y-axis.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
layer (obj): Layer object in which the beams are located. Alternative (str): String representing the layer name, conforming to VIIA naming convention. E.g. ‘N0’.
grid (obj): Grid object that the beams are plotted on. Alternative (int): ID of the grid object. Alternative (str): Name of the grid object.
gridlines (list of str or int): List containing the names of the gridlines on which the beams are plotted. The entries in the list can be either strings or integers.
shapes (list of obj): List of two surface shapes that the beams are created between.
beam_height (float): Elevation of the collar ties measured from the floor defined in floor_level. Alternative 1 (obj): Level object specifying the elevation of the collar ties measured from the ground. This level must be part of the given grid. Alternative 2 (str): String representation of a level object specifying the elevation of the collar ties measured from the ground. This level must be part of the given grid.
material (str): Name of the material of the beam shape to be created, complying VIIA naming convention.
geometry (str): Name of the geometry of the beam shape to be created, complying VIIA naming convention.
floor_level (float): Optional argument that specifies the height of the floor that may be used along with beam_height to determine the elevation at which to create the beams. This argument is required when beam_height is not a Level object. Alternative 1 (obj): Level object specifying the elevation of the floor. Alternative 2 (str): String representation of a level object specifying the elevation of the floor.
is_truss (bool): Select to transform the collar tie objects into truss objects. Default value is True.
is_roof_beam (bool): Select to indicate if the beam is part of the roof structure (and is plotted in the roof plot also in case of no roof sheeting). Default value is False.

Output:

Each beam described in the beam list is added to the project and the relevant collections.
A list containing all beam objects is returned.

viia_create_column(name: Union[str, Layer], material: str, geometry: str, points: List[List[Union[float, str, Shapes, Level]]], is_truss: bool = False) → Column

VIIA function to create a column shape based on layer, material, geometry and contour points. The column can be optionally turned into a truss element.

Warning

In this release a string containing the full name is still accepted as input for name. In future releases this functionality will be deprecated. Enter a layer object instead.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
name (str or Layer): Name of the layer as a string, or the Layer object itself, to which the newly created column should be added. Full name of shape is also accepted, not applying auto naming function, this will be removed in future releases.
material (str): Name of the material of the column shape to be created, complying VIIA naming convention.
geometry (str): Name of the geometry of the column shape to be created, complying VIIA naming convention.
points (list of list of floats and shapes): The start and end point of the column shape. Each point is a list of 3 floats or 2 floats and 1 shape. If 3 floats are given, the unmodified point is used. If 2 floats and 1 shape is given, the unknown coordinate at the index of the shape is calculated by projection on this shape. Shapes can be inputted as objects or strings e.g. [[19.2, 6, “roof_1”], [0, 1, 4]] or [[19.2, roof_1, 15], [0, 1, 4]]. The z-coordinate can also be provided as level object, or name of the level.
is_truss (bool): Select to transform the column object into a truss object. Default value is False.

Output:

Returns the created column object reference.
The column is added to the project and to the layer.

viia_create_columns_on_grid(layer: str, column_list: List[List[Union[str, int]]], grid: Optional[Union[Grid, int, str]] = None, is_truss: bool = False) → List[Column]

This function is used to set up the columns for a specific layer, making use of a grid system. A column list is given as input, in which each row represents a column. Each column is in turn represented by a list of five values; starting point, end point, z-coordinate, material and cross-section. The points to place the columns should be given in grid notation, for instance ‘A3’. The columns can be optionally turned into truss elements.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
layer (str): String specifying the layer, conform VIIA naming convention. For example: ‘N0’.
column_list (list): List containing the information of the individual columns, for example: [[‘D1’, 0.0, 3.0, ‘LIN-BETON’, ‘210x210’], [‘E4’, 0.0, 3.5, ‘LIN-HOUT’, ‘D180’], [[4.86, 6.01], 0.0, 3.0, ‘LIN-HOUT’, ‘50x100’]. This will create three timber columns with cross-sections 210x210, D180 and 50x100. The first column is created at grid point D1 from an elevation of 0 m to 3.0 m. The second column is created at grid point E4 from an elevation of 0 m to 3.5 m. The third column is created at x-coordinate 4.86 and y-coordinate 6.01 and spans from an elevation of 0 m to 3 m.
grid (Grid, int, str): Optional object, id or name of the grid to use. By default, the first grid in the collection is used.
is_truss: transforms all columns into trusses. Default value is False.

Output:

Each column described in the column list is added to the project and the relevant collections.
A list containing all column objects is returned.

Example:

project.viia_create_columns_on_grid(
    layer='N0',
    column_list=[['D1', 0.0, 3.0, 'LIN-BETON', '210x210'], ['E4', 0.0, 3.5, 'LIN-HOUT', 'D180'],
    [[4.86, 6.01], 0.0, 3.0, 'LIN-HOUT', '50x100']])

viia_create_connection(source: Union[Surfaces, Lines, str], target: Union[Surfaces, Lines, str], detail: str, is_linear=False, thickness_interface: Optional[float] = None, area_interface: Optional[float] = None, switch: bool = False, flip: bool = False, local_x_axis: Optional[list] = None, local_y_axis: Optional[list] = None, degrees_of_freedom: Optional[List[int]] = None)

Function to connect two shapes with a certain detail as described in Basis of Design (UPR).

Note

Before using this function make sure the two shapes are connected. For this the project.viia_connect_shape function can be used.

Warning

Check your result in the model, as there are a lot of exceptions known to cause an error when applying the function, when meshing or running the model in DIANA.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
source (obj): Object reference of source shape. This might be a surface or line-shape and depends on the requested detail. Alternative (str): The name of the source shape can be provided.
target (obj): Object reference of target shape. This might be a surface or line-shape and depends on the requested detail. Alternative (str): The name of the target shape can be provided.
detail (str): Detail number as described in the Basis of Design (UPR). For example ‘D2.01’. For hinges, it should be specified as ‘HINGE-P’ for point hinges and as ‘HINGE-L’ for line hinges. D2.01C is the same as D2.01B but the support area is a half (e.g beam supported in perimeter wall).
is_linear (bool): Select to apply linear material properties, default value is False.
thickness_interface (float): Option to manually set interface thickness for line interfaces, in [m]. Required for: D3.03.
area_interface (float): Option to manually set interface area for point interfaces, in [m2].
switch (bool): Option to switch the source and target shapes. If True, shapes are switched. Unlike the flip, the switch is performed in the geometry model. Default value is false.
flip (bool): Option to flip the local z-axis of the interface. If neither local_x_axis nor local_y_axis are defined, then the flip is done after the local axes have been corrected after making the model. The flip is only performed after running viia_create_model(). Default value is False.
local_x_axis (list): Option for point interfaces to manually define the local x-axis of the interface. Conversely, it can also be used to specify the local x-axis for hinges. If for hinges, please also specify the next argument local_y_axis.
local_y_axis (list): Option for point and line interfaces to manually define the local y-axis of the interface. Required for: D3.03.. Conversely, it can be used to specify the local y-axis of a hinge. If for hinges, please also specify the argument local_x_axis.
degrees_of_freedom (list with 3 integers): List with the rotational degrees of freedom to be tied when creating a hinge. The list contains the rotational degrees of freedom or rotation about the local x-, y- and z-axes.

Output:

The connection is created in PY-memory.

For example: >>> viia_create_connection(Wall1, Floor1, ‘D2.01’) >>> viia_create_connection(Wall1, Floor1, ‘HINGE-L’)

viia_create_cost_key_figures(facade_list: List[Union[str, Wall]] = None, generate_excel: bool = False) → Path

This function computes the cost key figures required by the cost engineer (at request of the client) and send them to MYVIIA.

Note

Area of inner walls is not required anymore by cost engineer, August 2022.

The data collected is:

BVO: Area of all the modelled floors (no fstrip and roofs), excluding the openings > 5m2, in [m2].

BBO: Area of all the modelled ground floors, in [m2].

BGO: Area of the facade including the openings in [m2].

OGO: Area of the openings in the facade in [m2].

BDO: Area of all the modelled roofs including the openings in [m2].

ODO: Area of all the openings in the modelled roofs in [m2].

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
facade_list (list of obj): List with names or object references of the wall objects that should be considered facades of the building structure. Default value is None, the area of the facade and the opening area of the facade are not computed.
generate_excel (bool): Select to return an Excel sheet with the values for the cost engineer. A template for this Excel file is available in the viiaPackage. Default value is True.

Output:

The cost key figures are calculated based on the model.
The values are sent to MYVIIA. These are uploaded if no prior values exist, or the values have changed.
The Excel with the values is created, the location of the file is returned.

viia_create_crm(template_locations: Dict[str, str], output_folder: Path = None) → List[Path]

This function creates the CRM deliverable for an object. Relevant data is assembled from project_information, cost estimation and cost key figures. Also, the applied measures are retrieved from MYVIIA from engineering database.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
template_locations (dict): Dictionary which stores the path of all requested template files.
output_folder (Path): Optional input for location where to create the report. Default value is None, indicating the default location is used. In normal production objects do not change this!

Output:

Filled template with combined information from project and myviia. Values that couldn’t be retrieved are marked unknown (NL: onbekend).
Returns list of created files.

viia_create_datas(data_names: Union[str, List[str]]) → Data

This function will create an instance of the Data class, based on VIIA naming convention.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
data_names (str): Name of the element data to be created. Alternative (list of str): List of multiple strings, the names of the data-models for the element data to be created. All data-models are part of a single instance of the Data class. The name of which is a combination of the names of the data-models.

Output:

Returns the object reference to the ‘Data’ object that is created based on the input arguments.
If name is not corresponding to the VIIA naming convention an error is raised.

viia_create_datfile(mesh: bool = True, load: bool = True) → Optional[Path]

This function creates a dat-file in the current analysis folder, or if this is not specified in the working directory. It will read the dat-file and collect the mesh information from it to update the model in py-memory. If software is not set to DIANA, nothing will be done. In DIANA the mesh will be regenerated when this function is applied, prior to generating the dat-file.

Warning

The model should be meshed in DIANA.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
mesh (bool): Select if the model should be meshed first. Default set to ‘True’.
load (bool): Select if the dat-file for DIANA should be loaded. This is not required if it was already loaded previously and no changes to the model have been made in the meantime. Default value is True.

Output:

A dat-file is written by DIANA.
The path of the dat-file is returned.

viia_create_dead_loads(shapes_list: List[Shapes], load_value: float, force_direction: Optional[Union[Direction, str]] = None)

This function applies a vertical dead load on a shape (can be point, line, or surface). The load is added as load and does not have a mass which is needed in dynamic calculations.

Note

Shapes can be from different classes, be aware that the unity of the value changes.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
shapes_list (list of objects): List with the object references on which the load will be applied. Alternative (list of strings): List of the names of the shapes on which the load is applied.
load_value (float): Value of the load acting in negative z-direction if shape is a surface in [N/m2], if shape is a line in [N/m] or if shape is a point in [N]. A vertical load that acts downward should have a positive value.
force_direction (obj): Object reference of direction of force Alternative (str): Direction can also be given as ‘X’, ‘Y’, or ‘Z’, or name of a direction of which an object is already created.

Output:

Load is created in ‘Load’ class.
If software is DIANA, and model is created, the load is added to the model.

viia_create_diagonal_gridline_two_points(points: List[List[float]], grid: Optional[Union[Grid, int, str]] = None, gridline_name: Optional[str] = 'R1', tags: Optional[List[str]] = None)

Function to create a diagonal gridline, by supplying two points.

Input:

project (obj): Project object containing collections of fem objects and project variables.
points (list): List of two 2D points between which to create a gridline
grid (Grid, int, str): Optional object, id or name of the grid to plot, by default the first grid in the collection is selected.
gridline_name (str): Optional string to assign as gridline name. Default value is ‘R1’.
tags (list): Optional list of tags to assign to the gridlines

viia_create_diagonal_gridlines_points_vector(points: List[List[float]], vector: List[float], grid: Optional[Union[Grid, int, str]] = None, gridline_names: Optional[List[str]] = None, tags: Optional[List[str]] = None)

Function to create diagonal gridlines in a specified grid, by supplying points and a direction.

Input:

project (obj): Project object containing collections of fem objects and project variables.
points (list): List of 2D points in which to create a gridline.
vector (list): 2D direction vector of the diagonal gridlines.
grid (Grid, int, str): Optional object, id or name of the grid to plot, by default the first grid in the collection is selected.
gridline_names (list): Optional list of strings to assign as gridline names. [‘R1’, ‘R2’, etc.] by default
tags (list): Optional list of tags to assign to the gridlines.

viia_create_dummy_plate_between_walls(wall_1: Wall, wall_2: Wall, material: str = 'LIN-DUMMY-PLATE', geometry: float = 100, z_coordinate: Optional[float] = None) → Wall

Function to create a dummy plate between two walls. This can be used for cavity walls for instance. The local x-axis of the plate is set parallel to the wall. The dummy plate is created in the Floor class.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
wall_1 (Wall): Object reference of the first wall.
wall_2 (Wall): Object reference to the second wall.
material (str): Optional material to apply to the dummy plate, default is ‘LIN-DUMMY-PLATE’.
geometry (float): Optional geometry to apply to the plate, default is 100mm.
z-coordinate (float): Optional z-coordinate for the plate, default is bottom of the walls

Output:

Object reference to the newly created dummy plate in the Floor class.

viia_create_floor(name: Union[str, Layer], material: str, geometry: str, points: List[List[List[Union[float, str, Shapes, Level]]]], element_x_axis: Optional[Union[List[float], str]] = None) → Floor

VIIA function to create a floor shape based on layer, material, geometry and contour points. The points list can also contain the openings in the floor shape.

Warning

In this release a string containing the full name is still accepted as input for name. In future releases this functionality will be deprecated. Enter a layer object instead.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
name (str or Layer): Name of the layer as a string, or the Layer object itself, to which the newly created floor should be added. Full name of shape is also accepted, not applying auto naming function, this will be removed in future releases.
material (str): Name of the material of the floor shape to be created, complying VIIA naming convention.
geometry (str): Name of the geometry of the floor shape to be created, complying VIIA naming convention. If naming convention dictates that the geometry is incorporated into the material (e.g. wood plank floors), setting the geometry to 0 skips the geometry parameter when generating the object name.
points (list of list of list of floats and shapes): The points of the contour and opening of the floor shape. Each point is a list of 3 floats or 2 floats and 1 shape. If 3 floats are given, the unmodified point is used. If 2 floats and 1 shape is given, the unknown coordinate at the index of the shape is calculated by projection on this shape. Shapes can be inputted as objects or strings. e.g. [[[0, 0, 0], [1, 0, 0], [1, “wall_1”, 0], [0, wall_1, 0]], [coordinates of opening1], [coordinates of opening2] etc.]. The z-coordinate can also be provided as level object, or name of the level.
element_x_axis (list of floats): Optional input to define direction of the local x-axis of the floor, which also defines the spanning direction of the floor. Default value is None, in which case the element-x-axis is set to the direction of the intersection of the surface with a horizontal plane. In case of a floor (with a horizontal surface), the local x-axis is set in the global x-direction. Alternative also the name of the direction can be provided.

Output:

Returns the created floor object reference.
The floor is added to the project and to the layer.

viia_create_floors_on_grid(layer: str, z_coordinate: float, floor_list: List[List[Union[str, float, list]]], grid: Optional[Union[Grid, int, str]] = None) → List[Floor]

This function is used to set up the floors for a specific layer, making use of a grid system. A floor list is given as input, in which each row represents a floor. Each floor is in turn represented by a list of corner points, a material, a geometry and an optional element_x_axis.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
layer (str): String specifying the layer, conform VIIA naming convention. For example: ‘N0’.
z_coordinate (float): The z_coordinate of the floors, in [m].
floor_list (list): List containing the information of the individual floors, for example [[‘A1’, ‘B1’, ‘B2’, ‘A2’, ‘LIN-HBV-PLANKEN-0.03-0.040-0.150-0.600’, 0, [0, 1, 0], [‘A2’, ‘B2’, ‘B1’, ‘C1’, ‘C3’, ‘A3’, ‘LIN-BETON’, 300],[[0,0], [7.5,0], [7.5,7.5], [0,7.5], ‘LIN-BETON’, 100]. This will create three rectangular floors. The geometry of the floor shape to be created, needs to comply to VIIA naming convention. If naming convention dictates that the geometry is incorporated into the material (e.g. wood plank floors), setting the geometry to 0 skips the geometry parameter when generating the object name. Optionally a local x-axis can be defined.
grid (Grid, int, str): Optional object, id or name of the grid to use. By default, the first grid in the collection is used.

Output:

Each floor described in the floor list is added to the project and the relevant collections.
A list containing all floor objects is returned.

Example

project.create_floors_on_grid(‘N1’, 3.0, floor_list)

An example of a floor list is:

floor_list = [[‘A1’, ‘B1’, ‘B2’, ‘A2’, ‘LIN-HBV-PLANKEN-0.03-0.040-0.150-0.600’, 0, [0, 1, 0]],: [‘A2’, ‘B2’, ‘B1’, ‘C1’, ‘C3’, ‘A3’, ‘LIN-BETON’, 300], [[0,0], [7.5,0], [7.5,7.5], [0,7.5], ‘LIN-BETON’, 100]]

The first floor in this list spans between gridpoints A1, B1, B2 and A2, is a ‘PLANKEN’ floor with the specified spacing and geometry parameters, and spans in the y direction([0, 1, 0]).

The second floor spans between six gridpoints, is made of concrete and has a thickness of 300mm. The element_x_axis is omitted, which means it will have default value [1, 0, 0].

The third floor spans between four x and y coordinates, is made of concrete and has a thickness of 100mm. The element_x_axis is omitted, which means it will have default value [1, 0, 0].

viia_create_foundation_columns_and_strips(columns: List[Union[Column, str]], foundation_depth: float, foundation_column_material: str, foundation_column_width: float, strip_material: Optional[str] = None, strip_width: Optional[float] = None, strip_thickness: Optional[int] = None, stepped_foundation_strip_extensions: Optional[List[float]] = None, stepped_foundation_strip_heights: Optional[List[float]] = None) → Tuple[Optional[List[Column]], Optional[List[Fstrip]]]

This function creates the foundation underneath all columns in the list. Only square cross-sections can be created for foundation columns and strips.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
columns (list): List with all the columns underneath which the foundation has to be made. The columns may be provided as string or as object reference of Column.
foundation_depth (float): Depth of the foundation strip, in [m].
foundation_column_material (str): Name of the foundation column material.
foundation_column_width (float): Width of the foundation column, in [mm]. Only square cross-sections can be used for foundation columns. So, the width and the height of the column are the same. In case of stepped foundation the width of the foundation column exactly below the ground column should be given.
strip_material (str): Name of the strip material. Default value is None.
strip_width (int): Width of the strip, in [mm]. In case of stepped foundation this input parameter should not be provided. Default value None.
strip_thickness (int): Thickness of the strip, in [mm]. In case of stepped foundation this input parameter should not be provided. Default value None.
stepped_foundation_strip_extensions (list of float): List of extensions for stepped foundations, in [mm]. Input parameter should only be provided for stepped foundations. Default value None. The extensions are provided at each level of the stepped foundation going from top to bottom

60 | | 60

—- —-

75 | | 75

—- —-

40 | | 40

—- —- | | ———————–

strip_extensions = [60, 75, 40]
stepped_foundation_strip_heights (list of float): List of extensions for stepped foundations, values in [mm]. Input parameter should only be provided for stepped foundations. Default value None. Height of the various levels of the stepped foundation going from top to bottom, in [mm].

|

—- —-

120 | |
—- —-

50 | |
—- —-

60 | |

height_levels = [120, 50, 60]

Output:

Returns lists of object references of newly created foundation columns (Column) and foundation strips (Fstrip).

viia_create_foundation_walls_and_strips(walls: List[Union[Wall, str, Tuple[Wall, Line]]], foundation_depth: float, strip_material: Optional[str] = None, strip_width: Optional[float] = None, strip_thickness: Optional[int] = None, stepped_foundation_strip_extensions: Optional[List[float]] = None, stepped_foundation_strip_heights: Optional[List[float]] = None, adjust_strips: bool = True, allow_outer_leafs: bool = False, adjust_for_cavity: bool = True, foundation_wall_material: Optional[str] = None, cavity_extension: Optional[float] = 0) → Tuple[Optional[List[Wall]], Optional[List[Fstrip]]]

Function creates the foundation underneath all walls in the list. The foundation strips are generated centered underneath the wall. In case of cavity walls, the foundation strip is generated underneath both leaves. The remaining strip width is equally distributed on both sides of the real wall including the cavity.

Note

The input cavity_extension should only be used when the cavity wall extends below the ground floor level, therefore, the default value is set to 0. When given value to cavity_extension, it should be the height (dimension in vertical direction) of the extension part in [mm]. In reality, it means the cavity was filled and foundation wall becomes solid below certain height of cavity extension.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
walls (list): List with all the walls underneath which the foundation has to be made. The walls may be provided as string or as object reference of Wall. If provided as tuple with a line shape-geometry, the foundation is applied only underneath that part of the wall. This last feature is not available for cavity walls.
foundation_depth (float): Depth of the foundation strip, in [m].
strip_material (str): Name of the strip material.
strip_width (int): Width of the strip, in [mm]. In case of stepped foundation this input parameter should not be provided. Default value None.
strip_thickness (int): Thickness of the strip, in [mm]. In case of stepped foundation this input parameter should not be provided. Default value None.
stepped_foundation_strip_extensions (list of float): List of extensions for stepped foundations, in [mm]. Input parameter should only be provided for stepped foundations. Default value None. The extensions are provided at each level of the stepped foundation going from top to bottom

60 | | 60

—- —-

75 | | 75

—- —-

40 | | 40

—- —- | | ———————–

strip_extensions = [60, 75, 40]
stepped_foundation_strip_heights (list of float): List of extensions for stepped foundations, values in [mm]. Input parameter should only be provided for stepped foundations. Default value None. Height of the various levels of the stepped foundation going from top to bottom, in [mm].

|

—- —-

120 | |
—- —-

50 | |
—- —-

60 | |

height_levels = [120, 50, 60]
adjust_strips (boolean): Switch to automatically adjust the fstrips so that they connect properly at intersections. This will remove overlapping parts, and add the missing area to connect the outer corners. Default value is True, performing the adjustment.
allow_outer_leafs (boolean): When set to true, foundations can be created below the outer leafs of cavity walls as well. Default value is False.
adjust_for_cavity (boolean): Toggle to place the foundation wall in the middle of the cavity. Default value is True. This input is not used and will be removed in future releases.
foundation_wall_material (str): Optional input to specify the material of the foundation wall. Default value is None, in which case the material of the wall is the same as that of the ground floor wall.
cavity_extension (float): The height of the ground floor cavity wall’s extension below ground floor level, in [mm]. Default is 0, which means ground floor cavity walls doesn’t extend into foundation

Output:

Returns lists of object references of newly created foundation walls (Wall) and foundation strips (Fstrip).

viia_create_fstrip(name: Union[str, Layer], material: str, geometry: str, points: List[List[List[Union[float, str, Shapes, Level]]]], element_x_axis: Optional[Union[List[float], str]] = None) → Fstrip

VIIA function to create a foundation strip shape based on layer, material, geometry and contour points. The points list can also contain the openings in the foundation strip shape.

Warning

In this release a string containing the full name is still accepted as input for name. In future releases this functionality will be deprecated. Enter a layer object instead.

Note

Foundation strips can only be created in the layer for foundations ‘F’.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
name (str or Layer): Name of the layer as a string, or the Layer object itself, to which the newly created foundation strip should be added.
material (str): Name of the material of the foundation strip shape to be created, complying VIIA naming convention.
geometry (str): Name of the geometry of the foundation strip shape to be created, complying VIIA naming convention. If naming convention dictates that the geometry is incorporated into the material (e.g. wood plank foundation strips), setting the geometry to 0 skips the geometry parameter when generating the object name.
points (list of list of floats and shapes): The points of the contour and opening of the foundation strip shape. Each point is a list of 3 floats or 2 floats and 1 shape. If 3 floats are given, the unmodified point is used. If 2 floats and 1 shape is given, the unknown coordinate at the index of the shape is calculated by projection on this shape. Shapes can be inputted as objects or strings. e.g. [[[0, 0, 0], [1, 0, 0], [1, “wall_1”, 0], [0, wall_1, 0]], [coordinates of opening1], [coordinates of opening2] etc.]. The z-coordinate can also be provided as level object, or name of the level.

Output:

Returns the created fstrip object reference.
The fstrip is added to the project and to the layer.

viia_create_gable_roof(layer: Union[Layer, str], wall_points: List, material_equivalent_plate: str, geometry_equivalent_plate: Union[int, float], height_ridge: Union[int, float], material_ridge: str = 'LIN-HOUT', geometry_ridge: str = None, material_wall_plate: str = 'LIN-HOUT', geometry_wall_plate: str = None) → List[Shapes]

Function to create basic roof structure based on two wall plates and height of ridge.

Note

The material of the collar tie can be modelled implicitly, or explicit. Select the appopriate material.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
layer (str or Layer): Name of the layer as a string, or the Layer object itself, to which the newly created roof should be added.
wall_points (list with lists with lists of 3 floats): A list which contains two lists with both two coordinates. The coordinates represent the start and endpoint of the wall plate.
material_equivalent_plate (str): Name of the material following VIIA naming convention.
geometry_equivalent_plate (int, float): Thickness of the equivalent plate.
material_ridge (str): Name of the material of the ridge following VIIA naming convention. Default value: ‘LIN-HOUT’.
geometry_ridge (str): Name of the geometry of the ridge following VIIA naming convention. Default value: None.
material_wall_plate (str): Name of the material of the wall plates following VIIA naming convention. Default value: ‘LIN-HOUT’.
geometry_wall_plate (str): Name of the geometry of the wall plates following VIIA naming convention. Default value: None.

Output:

Creation of the shapes for gable roof (sheeting, optionally ridge beam, wall plates). A list with all the newly created shapes is returned.

viia_create_geo_output_nlth(signal: str, bsc_nls_dir: Path, analysis: Analysis, output_5a: Optional[Path] = None, output_5b: Optional[Path] = None, abaqus_results: Optional[Path] = None, foundation_type: Optional[str] = None, tva_nls_dir: Optional[Path] = None) → Tuple[Optional[Path], Optional[Path]]

This function handles the results to collect the geo-output. It processes the tb-file(s) for pile, shallow and mixed foundations and calculates the foundation forces for a given signal. The force information from A10 or A13 is combined with that of A12 or A15 and the final json-file is created in the format required by the geotechnical advisor.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
signal (str): The signal for which the geo-output should be created. This should be given in the format ‘S1’.
bsc_ls_dir (Path): The full path to the folder containing the result json-file for the non-strengthened non-linear static flexbase analysis A10.
analysis (obj): Object reference of analysis of the results in the tb-file(s).
output_5a (Path): The full path of 5a tabulated file for fstrips elements and nodes. Mutually exclusive to abaqus_results. Default is None, shallow foundation is not considered (output_5b is then required).
output_5b (Path): The full path of 5b tabulated file for pile nodes. Mutually exclusive to abaqus_results. Default is None, pile foundation is not considered (output_5a is then required).
abaqus_results (Path): The full path to ABAQUS post processed results file. Mutually exclusive to output_5a/output_5b. Default value None.
foundation_type (str): The foundation type modelled in the model. The allowed values are ‘mixed’, ‘strips’ or ‘piles’. Default value None.
tva_nls_dir (Path): The full path to the folder containing the result json-file for the strengthened non-linear static flexbase analysis A13. If not provided the results from the BSC analysis are used. Default value None.

Output:

Handles the results from the NLTH analysis per signal (A12 or A15).
Merges the results with the results from the flexbase non-linear static analysis (A10 or A13).
Saves the json-file(s) to the specified folder.
The paths of the generated json-file is returned.

viia_create_geo_output_static_analysis(analysis: Analysis, output_5a: Optional[Path] = None, output_5b: Optional[Path] = None, abaqus_results: Optional[Path] = None, foundation_type: Optional[str] = None, output_dir: Optional[Path] = None) → Path

This function handles the results to collect the geo-output. It processes the tb-file(s) for pile, shallow and mixed foundations and calculates the normal forces per foundation strip or pile for A10 or A13 analysis. All the data is stored in a json-file.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
analysis (obj): Object reference of nonlinear static analysis.
output_5a (Path): The full path of 5a tabulated file for fstrips elements and nodes. Mutually exclusive to abaqus_results. Default is None, shallow foundation is not considered (output_5b is then required).
output_5b (Path): The full path of 5b tabulated file for pile nodes. Mutually exclusive to abaqus_results. Default is None, pile foundation is not considered (output_5a is then required).
abaqus_results (Path): The full path to Abaqus post processed results file. Mutually exclusive to output_5a/output_5b. Default value is None.
foundation_type (str): The foundation type modelled in the model. The allowed values are ‘mixed’, ‘strips’ or ‘piles’. Default value None, in which case it is derived from the model.
output_dir (Path): The path where the result json-file will be saved. Default value None, the json-file will be saved to the current analysis folder (this is the normal workflow in VIIA).

Output:

Generates the json-file with the geo-output from the flexbase non-linear static analysis.
Saves the json-file to the requested folder.
The path of the generated json-file is returned.

viia_create_geometry(geometry_name: str, material_object: Material, shape_object: Optional[Union[Shapes, str]] = None, class_type: Optional[str] = None)

This function contains all settings for the geometries that are set by the naming convention used in the VIIA project. These settings are project specific. If geometry names that are passed are not conform naming convention, an error may be raised.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
geometry_name (str): Name of the geometry, using the standard for VIIA project (see UPR).
material_object (obj): Object reference to the material of the shape.
shape_object (obj): Object reference to the shape the material is applied on. If class_type is provided the shape is not required. Default value is None. Required if the class_type is not provided.
class_type (str): Optional input of the type of object to apply the geometry on, for example ‘Floor’ or ‘Lintel’, default value is None. Required if the shape_object is not provided.

Output:

Updates the geometry name depending on the VIIA project settings.
Returns the object reference to the geometry (if not present, it is created)

viia_create_hip_roof(layer: Union[Layer, str], wall_points: List, material_equivalent_plate: str, geometry_equivalent_plate: Union[int, float], ridge: Union[List[List[Union[int, float]]], 'Line'], material_ridge: str = 'LIN-HOUT', geometry_ridge: str = None, material_wall_plate: str = 'LIN-HOUT', geometry_wall_plate: str = None) → List[Shapes]

Function to create basic roof structure based on two wall plates and height of ridge.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
layer (str or Layer): Name of the layer as a string, or the Layer object itself, to which the newly created roof should be added.
wall_points (list with lists with lists of 3 floats): A list which contains two lists with both two coordinates. The coordinates represent the start and endpoint of the wall plate
material_equivalent_plate (str): Name of the material following VIIA naming convention.
geometry_equivalent_plate (int, float): Thickness of the equivalent plate.
ridge (obj): Object reference of the line which represenst the ridge. Alternative (list with 2 lists of 3 floats): List with 2 coordinates of line, which represents the ridge.
material_ridge (str): Name of the material of the ridge following VIIA naming convention. Default value: ‘LIN-HOUT’.
geometry_ridge (str): Name of the geometry of the ridge following VIIA naming convention. Default value: None.
material_wall_plate (str): Name of the material of the wall plates following VIIA naming convention. Default value: ‘LIN-HOUT’.
geometry_wall_plate (str): Name of the geometry of the wall plates following VIIA naming convention. Default value: None.

Output:

Creation of the shapes for hip roof (sheeting, optionally ridge beam, wall plates). A list of all newly created objects is returned.

viia_create_layer(name: str, shapes: Optional[List] = None) → Layer

Function to create a layer in the class ‘Layer’ and add it to the project. The VIIA naming convention is applied. Only layers with names ‘F’, ‘N0’, ‘N1’ etc. and ‘B1’, ‘B2’ etc. are allowed.

Input:

project (obj): Project object containing collections of fem objects and project variables.
name (str): Name of the layer.
shapes (list): List of shapes that belong the layer that is created. Default None.

Output:

Returns the object created in the ‘Layer’ class.
The Layer is added to the project collections.

viia_create_levels(z_coordinates: List[float], level_names: List[str] = None, grid: Optional[Union[Grid, int, str]] = None) → List[Level]

Function to add multiple levels to a grid.

Input:

project (obj): Project object containing collections of fem objects and project variables.
z_coordinates (float): List of the z-coordinates of the levels, in [m]. This list will be sorted from lowest to highest before adding the levels.
level_names (str): Optional list of names of the levels. Must be unique in the grid-system it is added. By default, levels will be named [‘L1’, ‘L2’, etc.]. If levels are already present, the naming will continue after the highest number.
grid (Grid, int, str): Optional object, id or name of the grid to plot, by default the first grid in the collection is selected.

Output:

Returns a list of the objects created in the ‘Level’ class.

viia_create_line_supports_for_foundation_walls(walls: Optional[List[Wall]])

This function applies line-support to all wall elements with ‘FUNDERINGSWANDEN’ in name.

Note

Applying line-supports is not the default procedure and will interfere with the result handling. Only apply this function if you realy require it. Always discuss with your lead engineer.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
walls (objs): Optional object references to wall shapes to which line supports need to be applied as well. Alternative (strings): Names of the walls to which line-supports need to be applied.

Output:

Line-support is created at the bottom side of the foundation walls (‘FUNDERINGSWANDEN’ in name) and additional given walls.

viia_create_linemass(layer: str, points: List[List[float]], value: float, linemass_type='density', direction: List[Union[int, float]] = None, host: Shapes = None)

Function to apply beam elements to apply mass (as self weight of beam).

Warning

Currently line-mass type ‘mass-elements’ is not used within VIIA. If this is needed please contact the automation team.

Note

When line-mass type is set to ‘mass-elements’ the load will be added for static calculations.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
layer (str): Layer of the line-mass, determines the order for phasing.
points (list with two lists of three floats): Coordinates of begin and end point of LineMass.
value (float): Mass per meter [kg/m].
linemass_type (str): Type describes the way the mass is modelled. Default value is ‘density’, can be switched to ‘mass-elements’ to apply mass-elements instead of beam elements.
direction (list of 3 floats): The direction is used to apply the mass in x, y- or z-direction ([0, 0, 1] means that the mass acts only in x-direction). Value is only taken into account if type is set to ‘MassElements’. Default direction is set to None, in which case a vector of [1, 1, 1] is applied, the mass is applied in all directions.
host (obj): Shape object where the line-mass will be embedded to. Required if exporting to ABAQUS is needed.

Output:

Line-mass shape is created at the requested input coordinates.
Material, geometry and elementclass for LineMass are assigned (mass is applied by self weight in material). If software is DIANA and model created.

viia_create_linemass_beam(beam, extra_load: float)

Function to apply extra loads on beams. Geometry with different loads and/or functions should be separated into more geometries. Load is added by adjusting self weight of the line shape. Function is available for beams, columns and lintels.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
beam (obj): Object reference to the beam of which the density will be changed. Alternative (str): Name of the beam of which the density will be changed.
extra_load (float): The additional load in [N/m].

Output:

The material of the beam is updated to a new material with increased density to take into account the extra load.

viia_create_lintel(wall: Union[Wall, str, int], opening_number: int, lintel_material: str = 'LIN-BETON', lintel_type: str = '100x100', support_length: float = 0.1, lintel_slab: bool = False) → Lintel

This function creates a lintel for a given opening in a wall.

Note

The top side of the opening consists of at least two points on the same maximum height in z-direction.

Note

The lintel will be applied within the contour of the wall (if edge of wall is smaller than the support_length, the lintel will stop at the edge.

Note

When the lintel slab is needed for cavity walls, a dummy plate with 100mm thickness will be created as a Floor object.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
wall (obj): Object reference of the wall in which the opening is located for the lintel. Alternative the name of a wall can be provided.
opening_number (int): The number (>= 1) of the opening (first opening is number 1).
lintel_material (str): The material of the lintel, all VIIA materials available. Default is LIN-BETON.
lintel_type (str): The profile of the lintel, all profiles available as for beams. Use VIIA naming convention. Default is 100x100.
support_length (float): The length of the support in [m]. This is the distance from the corner of the opening to the end of the lintel. Default value is 0.1.
lintel_slab (boolean): By default is False. When set to True, a dummy plate will be created between outer leaf and inner leaf on the opening of the cavity wall

Output:

Lintel is created in PY memory.
If model is already created in DIANA, it will also add the lintel to the model and assign properties for material, geometry and data.

Warning

Lintels that lie on the same line (due to two adjacent windows on the same height) can theoretically overlap. For the default support length of 0.1m this is unlikely, but when higher support lengths are specified, this can occur.

viia_create_load_combination_base_motion(signal='S1')

This function creates the load-combinations for the seismic base motion situation in DIANA. If the dead load combination is not present yet, it will also be added first. The load-combinations with time signals are applied in the x-, y- and z-direction (3 load-combinations are created with the name ‘Base motion’ in it).

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
signal (str): Signal number of the signal to be applied, available signals are ‘S1’ to ‘S11’. Default value is signal 1 ‘S1’. Note that you can only select the signals for which you provided the details in viia_add_basemotion_signals.

Output:

3 load-combination (x-, y- and z-direction) objects are updated with new signal and adjusted name.
If no Base motion combination is present the geometry load-combinations are created in DIANA (if software is DIANA and model created).
If these are already present, the geometry load-combination are updated (name and signal), and if the model is already meshed, it also updates the load-combinations in mesh.
The status variable ‘CurrentSignal’ in ‘Project’ is updated to the new signal.

viia_create_load_combination_earthquake(signal='S1')

This function creates the load-combinations for the seismic situation in DIANA. If the dead load combination is not present yet, it will also be added first. The load-combinations with time signals are applied in the x-, y- and z-direction (3 load-combinations are created with the name ‘Earthquake’ in it).

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
signal (str): Signal number of the signal to be applied, available signals are ‘S1’ to ‘S11’. Default value is signal 1 ‘S1’.

Output:

3 load-combination (x-, y- and z-direction) objects are updated with new signal and adjusted name.
If no Earthquake combination is present the geometry load-combinations are created in DIANA (if software is DIANA and model created).
If these are already present, the geometry load-combination are updated (name and signal), and if the model is already meshed, it also updates the load-combinations in mesh.
The status variable ‘CurrentSignal’ in ‘Project’ is updated to the new signal.

viia_create_load_combination_push_over()

This function creates the geometry load combinations for push over analysis, the same name is retained from corresponding load-cases for ±xy directions, both single and multi line cases.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load-combination object is created if it is not present yet.
Load-combination is created in DIANA (if software is DIANA and model is created)

viia_create_load_combination_response_spectrum() → List[LoadCombination]

This function creates the geometry load combinations for modal response spectrum analysis, the same name is retained from corresponding load-cases for x- and y-directions.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load-combination object is created if it is not present yet.
Load-combination is created in DIANA (if software is DIANA and model is created)

viia_create_load_combination_rob_test()

This function creates the geometry load combination for the Rob-test situation in DIANA.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load-combination object is created if it is not present yet.
Load-combination is created in DIANA (if software is DIANA and model is created)

viia_create_load_combination_static()

This function creates the geometry load combination (‘DL’) for static situation in DIANA.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load-combination object is created if it is not present yet.
Load-combination is created in DIANA (if software is DIANA and model is created)

viia_create_loadcombination_base_motion(signal='S1')

This function creates the load-combinations for the seismic base motion situation in DIANA. If the dead load combination is not present yet, it will also be added first. The load-combinations with time signals are applied in the x-, y- and z-direction (3 load-combinations are created with the name ‘Base motion’ in it).

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
signal (str): Signal number of the signal to be applied, available signals are ‘S1’ to ‘S11’. Default value is signal 1 ‘S1’. Note that you can only select the signals for which you provided the details in viia_add_basemotion_signals.

Output:

3 load-combination (x-, y- and z-direction) objects are updated with new signal and adjusted name.
If no Base motion combination is present the geometry load-combinations are created in DIANA (if software is DIANA and model created).
If these are already present, the geometry load-combination are updated (name and signal), and if the model is already meshed, it also updates the load-combinations in mesh.
The status variable ‘CurrentSignal’ in ‘Project’ is updated to the new signal.

viia_create_loadcombination_earthquake(signal='S1')

This function creates the load-combinations for the seismic situation in DIANA. If the dead load combination is not present yet, it will also be added first. The load-combinations with time signals are applied in the x-, y- and z-direction (3 load-combinations are created with the name ‘Earthquake’ in it).

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
signal (str): Signal number of the signal to be applied, available signals are ‘S1’ to ‘S11’. Default value is signal 1 ‘S1’.

Output:

3 load-combination (x-, y- and z-direction) objects are updated with new signal and adjusted name.
If no Earthquake combination is present the geometry load-combinations are created in DIANA (if software is DIANA and model created).
If these are already present, the geometry load-combination are updated (name and signal), and if the model is already meshed, it also updates the load-combinations in mesh.
The status variable ‘CurrentSignal’ in ‘Project’ is updated to the new signal.

viia_create_loadcombination_push_over()

This function creates the geometry load combinations for push over analysis, the same name is retained from corresponding load-cases for ±xy directions, both single and multi line cases.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load-combination object is created if it is not present yet.
Load-combination is created in DIANA (if software is DIANA and model is created)

viia_create_loadcombination_responsespectrum() → List[LoadCombination]

This function creates the geometry load combinations for modal response spectrum analysis, the same name is retained from corresponding load-cases for x- and y-directions.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load-combination object is created if it is not present yet.
Load-combination is created in DIANA (if software is DIANA and model is created)

viia_create_loadcombination_rob_test()

This function creates the geometry load combination for the Rob-test situation in DIANA.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load-combination object is created if it is not present yet.
Load-combination is created in DIANA (if software is DIANA and model is created)

viia_create_loadcombination_static()

This function creates the geometry load combination (‘DL’) for static situation in DIANA.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load-combination object is created if it is not present yet.
Load-combination is created in DIANA (if software is DIANA and model is created)

viia_create_loads(load: str, force_value: Optional[float] = None, force_direction: Optional[Union[Direction, List[float], str]] = None, connecting_shapes: Optional[List[Shapes]] = None, mode: Optional[List[int]] = None, ref_line_load: Optional[float] = None, category: Union[str, List[str]] = None, displacement_signals: Union[Path, str, Dict] = None)

This function creates a given predefined load, coupled to the requested load-types for the NLTH and NLPO.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
load (str): determines which load is applied, available are default project loads: ‘Self weight’, ‘Imposed load’, ‘Resting load’, ‘Rob-test’, ‘Base motion’, ‘Push_over_equivalent_acc’, ‘Push_over_modal’, ‘Push_over_uniform’ and ‘MRS_loads’. Based on this load selection additional arguments may be required.
load_value (float): Value of the load acting in negative z-direction if shape is a surface in [N/m2], if shape is a line in [N/m] or if shape is a point in [N]. A vertical load that acts downward should have a positive value. For the NLPO analysis, the default value is unit acceleration, in [m/s2].
force_direction (obj): Object reference of direction of force Alternative (list of 3 floats or float): Direction of force, for example [1,0,0] Alternative (str): Direction can also be given as ‘X’, ‘Y’, or ‘Z’, or name of a direction of which an object is already created. Alternative (str): For the Redis pushover, provide one of the following: ‘X_pos’, ‘X_neg’, ‘Y_pos’ or ‘Y_neg’.
connecting_shapes (list of objects): List with the object references on which the load will be applied.
mode (list of int): Integer of which mode is considered for modal pushover load-case. First item is x-direction dominating mode, second is Yy-direction dominating mode.
ref_line_load (float): Reference line-load in [N/m] for the case of the triangular load-case, see NLPO protocol.
category (str): The category of the imposed loads, refer to the basis of design (UPR). The category can be (only one category can be chosen): ‘AFloor’, ‘AStairs’, ABalc’, ‘BOffice’, ‘CSchool’, ‘C1_2’, ‘C3_5’, ‘DShop’, ‘E’, ‘F’, ‘HRoof’.
displacement_signals (Path, str or dict): Json file containing the displacement signals for the displacement controlled Redis push-over.

Output:

Load object created in PY-memory if not yet present in project.collections.loadsets.
Geometry load is added to the model in DIANA if software is DIANA and model created.

viia_create_main_surface_reinforcement(name: Union[str, Layer], material: str, geometry: str, points: List[List[Union[float, str, Shapes, Level]]], host_members: Optional[List[Union[Floor, Wall]]] = None, discretisation: str = 'element', element_x_axis: Optional[Union[List[float], str]] = None, regions: Optional[List['Regions']] = None) → MainSurfaceReinforcement

VIIA function to create main surface reinforcement shape based on layer, material, geometry and contour points. The points list can also contain the openings in the main surface reinforcement shape.

Warning

In this release a string containing the full name is still accepted as input for name. In future releases this functionality will be deprecated. Enter a layer object instead.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
name (str or Layer): Name of the layer as a string, or the Layer object itself, to which the newly created main surface reinforcement should be added.
material (str): Name of the material of the main surface reinforcement shape to be created, complying VIIA naming convention.
geometry (str): Name of the geometry of the main surface reinforcement shape to be created, complying VIIA naming convention.
points (list of list of floats and shapes): The points of the contour and opening of the main surface reinforcement shape. Each point is a list of 3 floats or 2 floats and 1 shape. If 3 floats are given, the unmodified point is used. If 2 floats and 1 shape is given, the unknown coordinate at the index of the shape is calculated by projection on this shape. Shapes can be inputted as objects or strings. e.g. [[[0, 0, 0], [1, 0, 0], [1, “wall_1”, 0], [0, wall_1, 0]], [coordinates of opening1], [coordinates of opening2] etc.]. The z-coordinate can also be provided as level object, or name of the level.
host_members (obj): Optional input for a list of object reference of the shape to which the reinforcement belongs. Default value is None.
discretisation (str): Setting for the meshing of the surface reinforcement. Meshing can be based on the mesh elements it is embedded in, ‘element’, or based on the shape itself, ‘section’. Default value is ‘element’.
element_x_axis (obj): Optional input to define direction of the local x-axis of the roof, which also defines the spanning direction of the roof. Default value is None, in which case the element-x-axis is set to the direction of the intersection of the surface with a horizontal plane. In case of a roof (with a horizontal surface), the local x-axis is set in the global x-direction.
regions (list of obj): List of object references of a region (surface) within the surface shape. It may not overlap the contour of the surface shape, but openings might be. Openings need to be set in the surface shape and cannot be set as part of the region. Default value is None.

Output:

Returns the created main surface reinforcement object reference.
The main surface reinforcement is added to the project and to the layer.

viia_create_mass_all_horizontal_surface_openings() → List[LineMass]

This function creates a line mass in all horizontal surfaces openings in the model, all four edges.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Returns regular truss-elements are added to all the openings in horizontal surfaces the model on four edges of the opening. Material, geometry and elementclass for LineMass are attached (mass is applied by self weight in material).

viia_create_mass_all_openings(unsupported_mass_on_opposite: bool = False) → List[LineMass]

Function to apply regular truss elements to account for mass on top- and bottom edge of all openings in the project.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
unsupported_mass_on_opposite (bool): States whether to double the mass density of supported line-masses opposite to unsupported line-masses. The default value is False.

Output:

Beam shape is added to the model on top and bottom of opening. Material, geometry and elementclass for LineMass are attached (mass is applied by self weight in material).

viia_create_mass_all_roof_openings(excluded_roofs: Optional[List[Union[Roof, str, int]]] = None, unsupported_mass_on_opposite: bool = False) → List[LineMass]

Function to add mass to all roof openings in the project. The user can exclude roofs if desired.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
excluded_roofs (list): List of roofs to exclude. Can either be an object reference, or simple name like ‘roof_4’ or ID.
unsupported_mass_on_opposite (bool): States whether to double the mass density of supported line-masses opposite to unsupported line-masses. The default value is False. This input only effects inclined roofs

Output:

Adds mass for all openings in the roofs provided.

viia_create_mass_all_wall_openings(unsupported_mass_on_opposite: bool = False) → List[LineMass]

This function creates a line mass in all wall openings in the model, top and bottom edge. The outer leaf of cavity walls is excluded in the function.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
unsupported_mass_on_opposite (bool): States whether to double the mass density of supported line-masses opposite to unsupported line-masses. The default value is False.

Output:

regular truss-elements are added to all the openings in walls the model on top and bottom of opening. Material, geometry and element-class for LineMass are attached (mass is applied by self weight in material)

viia_create_mass_horizontal_surface_openings(shape: Union[Floor, Roof, str]) → List[LineMass]

Function to apply regular truss elements on four edges of opening to apply mass.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
shape (obj): Object reference of the horizontal surface, i.e., floors or flat roofs, on which openings mass will be applied. Alternative (str): Name of the floor or flat roof.

Output:

Line masses are added to the model on all edges of all openings in the shape. The LineMass objects are only

added to the project if the LineMass objects can be fully supported by (a set of) host shape(s). Linemasses that do not meet this requirement are not created. The missing masses are subsequently spread out over the other LineMasses that are fully supported by (a set of) host shape(s).

viia_create_mass_roof_openings(roof: Union[Roof, str], unsupported_mass_on_opposite: bool = False) → List[LineMass]

Function to apply regular truss elements on top- and bottom edge of opening to apply mass.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
roof (obj): Object reference of the roof (or inclined floor) on which openings mass will be applied. Alternative (str): Name of the roof.
unsupported_mass_on_opposite (bool): States whether to double the mass density of supported line-masses opposite to unsupported line-masses. The default value is False.

Output:

Line mass is added to the model on top and bottom of opening. Material, geometry and elementclass for LineMass are attached (mass is applied by self weight in material).

viia_create_mass_wall_openings(wall: Union[Wall, str], unsupported_mass_on_opposite: bool = False) → List[LineMass]

Function to apply regular truss elements on top- and bottom edge of opening to apply mass.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
wall (obj): Object reference of the wall on which openings mass will be applied. Alternative (str): Name of the wall i.e. ‘N0-WANDEN-MW-KLEI>1945-110-1’.
unsupported_mass_on_opposite (bool): States whether to double the mass density of supported line-masses opposite to unsupported line-masses. The default value is False.

Output:

Beam shape is added to the model on top and bottom of opening. Material, geometry and elementclass for LineMass are attached (mass is applied by self weight in material).

viia_create_material(material_name: str, hbv_span: Optional[float] = None, hbv_width: Optional[float] = None)

This function contains all settings for the materials that are set by the naming convention used in the VIIA project. These settings are project specific. If material names that are passed are not conform naming convention, an error may be raised.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
material_name (str): Name of the material, using the standard for VIIA project (see UPR).
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:

Updates the material name depending on the VIIA project settings.
Returns the object reference to the material (if not present, it is created)

viia_create_model(software: str = 'VIIA')

Function selects the program to which the model must be exported or created in. For VIIA only SCIA and DIANA are used, but other programs can be selected.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
software (str): Software in which the model is created. Default setting for VIIA is ‘diana’ for ‘NLPO’ or ‘NLTH’ and ‘scia’ for ‘MRS’ analysis type. In case the object needs to be created in ABAQUS software provide ‘abaqus’ as input (will only work for NLTH analysis objects).

Output:

If software is ‘abaqus’: The model is created in ABAQUS. But only if the analysis type is NLTH.
If software is ‘diana’: The model is created in DIANA, when running in DIANA.
If software is ‘scia’: The xlm with model data is created and can be loaded in SCIA.

viia_create_model_plots(return_plot_data: bool = False, dpi: Optional[int] = None, appendix_pictures_folder: Optional[Path] = None)

This function creates most of the pictures for appendix of building setup using the Grid and Layer objects that should be present in the model.

Note

All picture names must correspond to how pictures are inserted into the Appendix of building structural setup template in the function _viia_create_model_plots_appendix.

The following picture are taken:

Grids - all
Side views - from two sides
Foundations - Overview and cross-section details
Floors - all layers
Walls (and columns) - all layers
Beams and lintels - all layers, except roof beams
Roof beams
Roof structure
Loads - all layers, dead loads and live loads

Input:

project (obj): Project object containing collections and of fem objects and project variables.
return_plot_data (bool): If true, will return the plotting information for testing
dpi (int): Dots per inch argument which is used to increase the resolution of the image. Default value is None.
appendix_pictures_folder (Path): Optional input for location where all the appendix pictures should be stored. Default value is None.

Output:

Pictures are created and saved in the folder ‘Appendix Pictures’ in the workfolder.

viia_create_model_plots_appendix(template_file: Optional[Path] = None, output_folder: Optional[Path] = None, pictures_folder: Optional[Path] = None) → Path

This function creates appendix of building setup for the engineering report.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
template_location (Path): Optional input for the location of the template file. Default value None. If not provided the file will be selected from the template library within this function.
output_folder (Path): Optional input for location where to create the report appendix. Default value is None, indicating the default location is used. In normal production objects do not change this!
pictures_folder (Path): Optional input for location where all the pictures should be collected from. Default value is None. In which case the appendix pictures folder set in project is used.

Output:

The requested report is generated with the information of the object in py-memory, databases and local (image-) files. It is saved in the ‘ER’ folder of the working folder or the location of the folder mentioned in the input.

viia_create_movie_diana(analysis: Optional[Union[str, Analysis]] = None, output_block: str = 'OUTPUT_MOVIE', result_type: Optional[str] = None, result_component: str = 'TrDtXYZ', deformation_type: str = 'absolute', deformation_scale_factor: Optional[float] = None, deformed_edge_view: int = 1, undeformed_edge_view: int = 1, fixed_legend: bool = True, min_legend_value: float = 0, max_legend_value: float = 60, save_movie: bool = True, frames_per_second: int = 12, width: int = 1024, height: int = 768, output_file_type: str = 'avi', units: Optional[Dict[str, str]] = None, diana_view_point: Optional[Union[Tuple, List]] = None) → Optional[Path]

Function to prepare and create a movie of the results in DIANA software.

Input:

project (obj): Project object containing collections of fem objects and project variables.
analysis (str or obj): Name of the analysis or the object reference of the analysis with the results for the movie. Default value is None, in which case the analysis will be retrieved from project, but only if there is one present, otherwise the user should specify which analysis to use.
output_block (str): Name of the output block in DIANA. Default value is ‘OUTPUT_MOVIE’.
result_type (str): Type of result to be shown in the movie. Example: ‘Displacements (2498)’. Default value is None.
result_component (str): Component of the result to be shown in the movie. Default value is ‘TrDtXYZ’. Other options can be ‘TrDtX’, ‘TrDtY’, ‘TrDtZ’ etc.
deformation_type (str): Type of deformation to be shown in the movie. Default value is ‘absolute’ or it can also be set to ‘normalized’.
deformation_scale_factor (float): Scale factor for the deformation. Default value for absolute deformation is 10 and for normalized deformation is 0.05.
deformed_edge_view (int): Option to select the deformed mesh edge view in DIANA. Default value is 1. Allowable values are:

1: Free face edges 2: Feature edges 3: No edges
undeformed_edge_view (int): Option to select the undeformed mesh edge view in DIANA. Default value is 1. Allowable values are:

1: Free face edges 2: Feature edges 3: No edges
fixed_legend (bool): Option to set the legend to fixed values. Default value is True.
min_legend_value (float): Minimum value for the legend. Default value is 0.
max_legend_value (float): Maximum value for the legend. Default value is 60.
save_movie (bool): Option to save the movie. Default value is True.
frames_per_second (int): Number of frames per second in the movie. Default value is 12.
width (int): Width of the movie display. Default value is 1024 pixels.
height (int): Height of the movie display. Default value is 768 pixels.
output_folder (str or Path): Folder location where the movie should be saved. By default, the movie will be saved in the workfolder.
output_file_type (str): Type of the output file. Default value is ‘avi’. It can also be set to ‘ogg’.
units (dict): Dictionary with the type of units and its desired unit. Default value is {‘LENGTH’: ‘mm’}. Some of the other examples can be {‘MASS’: ‘KG’}, {‘FORCE’: ‘KN’}, {‘TIME’: ‘SEC’} etc.
diana_view_point (View, list or tuple): The view point that should be used for the picture. Can be used when the default view is not sufficient. (Use ‘currentViewPoint()’ in DianaIE to retrieve the DIANA view point). The DIANA view point is a list or tuple of 11 floats where: 1st to 3rd values are camera position coordinates, 4th to 6th values are camera view vector direction, 7th to 9th values are camera focal point coordinates, 10th value is camera viewing angle in degrees and 11th value is the viewpoint height. When None the default view will be used. Default is None, using the ISO1 viewpoint.

Output:

The movie settings are set in DIANA.
As per user choice, the movie is saved in the specified folder.

viia_create_nonlinear_concrete_wall(wall: Union[Wall, str], rebar_position='Center', concrete_material='BETON-C20/25', rebar_material='LIN-WAP-B500', horizontal_rebar='R12_150', vertical_rebar='R12_150', rebar_distance: float = 0.035)

This function replaces a previously modelled linear concrete wall with a non-linear concrete wall. It adjusts the properties of the original wall to the specified concrete strength and applies grid reinforcement. It maintains existing openings and can be applied on walls in all directions. Optional is the inclusion of eccentricity.

Note

x-axis is expected to be horizontal.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
wall (obj): The wall that will be modelled with non-linear material properties and rebar added. Alternative (str): Name of the wall. The wall must have been created already in PY-memory.
rebar_position (str): Not obligatory, default value is ‘Center’. In that case no eccentricity is applied. If ‘Eccentric’ the grid reinforcement will be applied with corresponding eccentricity.
concrete_material (str): The name of the new non-linear concrete material.
rebar_material (str): The name of the material used for the reinforcement.
vertical_rebar (str): The definition of the vertical reinforcement that is used.
horizontal_rebar (str): The definition of the horizontal reinforcement that is used.
rebar_distance (float) in m: Distance from center of the reinforcement to the edge of the wall, i.e. coverage.

Output:

The linear concrete wall is replaced with a non-linear reinforced concrete wall and modelled in DIANA or SCIA.

For example:

>>> viia_create_nonlinear_concrete_wall(wall5)

This example will replace the linear concrete wall in the model with a non-linear concrete wall with a double grid reinforcement in the center.

>>> viia_create_nonlinear_concrete_wall(wall5, Type='Eccentric', horizontal_rebar='2R8_200')

In this example, the grid reinforcement has been applied with eccentricity, meaning that one reinforcement sheet is added at both sides of the wall. Also, different horizontal rebar is specified: 2Ø8-200.

viia_create_object_jira(jira_board: str, object_nr: Optional[str] = None, analysis_type: Optional[str] = None, object_size: Optional[str] = None, assignee_email: Optional[str] = None)

This function connects with JIRA REST API in order to create object tasks on VIIA JIRA boards. JIRA credentials in the user_config are required for this function The following entry is expected in the user_config connection_dict:

{'jira': {
    'email': 'employee.lastname@rhdhv.com',
    'token': 'abc123XYZ'}}

The API token can be created on the JIRA website in the ‘Security’ tab of account settings: https://id.atlassian.com/manage-profile/security/api-tokens

Input:

project (obj): ViiaProject to retrieve project data from
jira_board (str): Referring to the board of the corresponding production team. Choose from ‘DIANA1’, ‘DIANA2’, ‘DIANA3’, ‘DIANA4’, ‘DIANA5’ and ‘DIANA6’.
object_nr (str): VIIA object number.
analysis_type (str): Select the analysis type for the object, for example ‘NLTH’.
object_size (str): Select from ‘Small’, ‘Medium’ and ‘Large’.
Optional: assignee_email (str): Email-adress with which the desired assignee is registered at the JIRA board.

Output:

An epic and all user stories for the object will be created in the requested JIRA board, including components and story points, and assignee if selected.

viia_create_orthogonal_grid(gridline_list: Union[List[List[float]], List[List[Union[List[float], str]]]], names_verticals: Optional[Union[List[str], str]] = None, names_horizontals: Optional[Union[List[str], str]] = None, name: str = 'Grid') → Grid

Function to add an orthogonal grid to a project.

Input:

gridline_list: List of locations for gridlines. This can either consist of a list with lists of x- and y-coordinates, or a more elaborate list that includes tags. Examples of input are given below.
names_verticals: Optional parameter to change the names of the verticals. Default is A, B, C, etc.
names_horizontals: Optional parameter to change the names of the horizontals. Default is 1, 2, 3 etc.
name (str): Optional name to assign to the grid. Default name is ‘Grid’.

Output:

Creates, adds to project and returns the created Grid object.

Example

Two types of input can be given:

Simple input:

project.create_orthogonal_grid([[0, 2.0, 2.5, 3.5], [0, 1.0, 1.5, 5.2]])

This can be used to quickly set up an orthogonal grid without any tags.

More elaborate (including tags):

project.create_orthogonal_grid([[[0, 3.5], [0, 5.2], 'ground_floor'], [[2.0, 2.5], [1.0, 1.5], 'first_floor']])

This can be used to add gridlines that have tags. This may be useful for plotting larger grids, where only specific gridlines are useful on a specific level. If duplicate coordinates are given here, only the tags are added to the relevant gridlines.

viia_create_outer_leaf(wall: Union[Wall, str], cavity: float, outer_wall_thickness: Optional[float] = None, outer_wall_material: Optional[str] = None, flip: bool = False) → Wall

Function to create an outer leaf for a specific wall. All points defining the wall object are translated outward so the gap between them, including thickness of the wall, will be equal to cavity.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
wall (Wall, str): Wall object or string describing the inner leaf. For instance ‘wall_18’.
cavity (float): Cavity distance between the walls.
outer_wall_thickness (float): Optional thickness of the outer wall in [m]. If nothing is provided, thickness will be equal to the given wall.
outer_wall_material (str): Optional material of the outer wall. If nothing is provided, material will be equal to the given wall.
flip (bool): Toggle to flip the direction of creation of the wall. By default, the outer wall is created in the direction of the normal vector of the wall.

Output:

Object reference to the newly created outer wall in the Wall class.

viia_create_piles(coordinates: List[List[float]], support_type: str = 'FixedBase', pile_dimension: Optional[float] = None, pile_shape: Optional[str] = None, cross_section: Optional[str] = None, pile_group: Optional[str] = None, new_pile_foundation: bool = True, is_linear: bool = False, pile_numbers: Optional[List[Union[int, str]]] = None, plot_diagram: bool = False, horizontal_stiffness_factor: float = 1.0) → List[Union[Pile, PointSupport]]

Function to create the pile foundation supports. The pile foundation can be modelled for fixed-base or flexbase. It will apply the supports for piles in the model. The pile will be connected to the foundation strip surface at that location (surface shape in Fstrip class).

Note

If piles are located at the positions where there are several strips overlapping the same area at different height, the piles will be created under the lowest strip.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
coordinates (list of lists 2 floats): The x- and y-coordinate of the positions of the piles. The z-coordinate should not be provided.
support_type (str): Type of shallow foundation, available are ‘FixedBase’, ‘FlexBaseGlobal’ and ‘FlexBaseFinal’. Default value ‘FixedBase’.
pile_dimension (float): Dimension used for the pile, can be diameter or width/height of the cross-section. Implementation based on the pile_shape, in [m]. This input is only used in FixedBase. Default value None.
pile_shape (str): Type of shape of the pile. If ‘circular’ is selected a circular cross-section is created otherwise a square cross-section. Default value is ‘square’. The shape should relate to the selected rebar configuration. This input is only used in FixedBase. Default value None.
cross_section (str): Alternative input for pile shape and dimension. The geometry of the pile cross-section, can be provided, following VIIA geometry name convention (e.g. ‘D200’ for circular cross-section with 200 mm diameter, ‘200x200’ for rectangular cross-section with 200 mm width). Note that only square piles are allowed. This input is only used in FixedBase and will only be used if pile_shape and pile_dimension are None. Default value None.
pile_group (str): Name of the pile group (e.g. A, B, C…), to retrieve pile data from MYVIIA.
new_pile_foundation (bool): Select to remove all piles if foundation type is not changed (you should set to False if you are adding multiple pile-groups for all next pile-groups). Default value is True, removing any existing piles.
is_linear (bool): The piles can be modelled with linear material properties. This entails no failure criteria for the springs and linear concrete, without rebar modelling. Default value is False, normal non-linear behaviour is modelled.
pile_numbers (list): List of pile numbers that is used to number the piles. The user can overrule the auto-numbering by providing this list. The list should be of equal length as the list of coordinates. Default value is None, in which case the piles are numbered regularly (based on order of creation). It is also possible to provide a list of strings.
plot_diagram (bool): Option to create plot of the force-elongation diagram for the pile group. It will create an image in a folder ‘Pile properties’ in the working folder. Default value is False. Only applicable for flexbase piles, value ignored in other situations.
horizontal_stiffness_factor (float): Specifies the factor to adjust the horizontal stiffness of the piles. Default value is 1.0. Only applicable for flexbase piles, value ignored in other situations.

Output:

Returns list of created piles and point supports.

viia_create_plots(collections: Optional[Union[List[Shapes], List[str]]] = None, layers: Optional[Union[List[Layer], List[str]]] = None, add_collections: Optional[Union[List[Shapes], List[str]]] = None, alpha: float = 0.7, add_alpha: float = 0.7, viewpoint: Optional[List[float]] = None, show: bool = True, title: Optional[str] = None, save_folder: Optional[Path] = None, file_name: Optional[str] = None, use_plotly: bool = False, save_plot: bool = True, return_figure: bool = False, legend_group_dict: Dict[Shapes, str] = None) → Union[Optional[Path], Tuple[Optional[Path], Any]]

This function enables to create a plot of the shapes stored within the project in the Python database as collections with an interactive GUI from Matplotlib.

Input:

project (obj): VIIA Project object containing collections of VIIA objects and project variables.
collections (list of obj): The list of shapes to be plotted. The list must contain references to VIIA objects in Shapes class. Cannot be used when layers are also given. Alternative 1 (list of str): List of string representations of shape collections to be plotted. If layers are defined, then only shapes of the specified collections on the specified layers are plotted. Default value is None, in which case all shapes are plotted.
layers (list of obj): The list of layer objects for which shapes need to be plotted. Alternative (list of str): list of layer names, the shapes of which need to be plotted Default value is None, in which case all layers are plotted.
add_collections (list of obj): The list of additional shapes to be plotted besides those plotted in the specified layers. The list must contain references to VIIA objects in Shapes class. This should be used when specific layers are given, and the additional shapes should be shapes that are not in the specified layers or if collection is passed as a list of strings, and you want plot some additional shapes. Alternative 1 (list of str): List of string representations of additional shape collections to be plotted besides those plotted in the specified layers. Default value is None, in which case no additional shapes are plotted.
alpha (float): Number from 0 to 1 that determines the transparency of the shapes that are plotted. Default value is 0.7.
add_alpha (float): Number from 0 to 1 that determines the transparency of the additional shapes that are plotted that are defined by ‘add_collections’. Default value is 0.7.
viewpoint (list of float): List of two floats that determine the angle the plot is viewn from when first created. The first entry is the elevation angle in degrees, and the second entry is the azimuth angle in degrees. For a topview use [90, 0].
show (bool): This is used to show the plot. By default, this is set to True. If set to False, the GUI with the plot will not appear.
title (str): Title to be used in picture. Default value is None, in which case the title is set based on the shape types and layer.
save_folder (str): Path to folder where the pictures should be saved. Default value is None, in which case the current workfolder will be used.
file_name (str): Name of the file to save the plot as.
use_plotly (bool): Indicates if plotly should be used instead of matplotlib. Default is False.
save_plot (bool): Indicates if the plot should be saved. Default is True.
return_figure (bool): Indicates if next to the path of the save file also the picture object of matplotlib or plotly should be returned. Default is False.
legend_group_dict (dict): A dictionary with shape and the legend group that should be applied for it. This is only available for plotlty plots. Default is None.

Output:

The requested shapes are plotted in an interactive GUI.
The path to where the saved file is returned if save_plot is True.

viia_create_pointmass(point: Union[List[float], Node], mass: float, layer: Union[str, Layer]) → PointMass

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
point (list of 3 floats): Point to apply the point-mass shape. Alternative (obj): Object reference of the node to apply the point-mass shape.
mass (float): Mass of the point-mass in [kg]. Mass is applied in x-, y- and z-direction.
layer (str or Layer): Name of the layer as a string, or the Layer object itself, to which the newly created point-mass should be added. Full name of shape is also accepted, not applying auto naming function, this will be removed in future releases.

Output:

Object for point-mass is created and attributes are set.
Object-reference is added to list of point_masses, points and shapes (in collections of project).
Project settings for shapes are applied (if any given).
Point-mass is created in DIANA (if software is DIANA and model created).
Material, data, elementclass_type, colour and mesh properties are assigned in DIANA (if software is DIANA and model created).

viia_create_report(report_type: str = 'TVA', governing_analysis: str = None, soil_investigation: bool = True, scope_change_id: Optional[int] = None, werkpakket_lst: Optional[List[str]] = None, extra_object_parts: Optional[List[str]] = None, output_folder: Path = None, images_folder: Path = None, input_folders: Dict[str, Union[Path, Dict[str, Path]]] = None) → List[Path]

This function creates the required report for VIIA. It will collect the correct template (depending on the tender specification which is defined on MYVIIA), collect the required data for the report (from local work-folder sources and/or MYVIIA) and generate the report.

Note

The tender specification (NL: vraagspecificatie) is retrieved from MYVIIA. If this is incorrect inform the project-leader. The projectleader can check and make sure that MYVIIA is updated.

With this function you can create different reports for VIIA. Some reports require specific additional input. The following report-types are available; these require input for the items mentioned. Input for other items is ignored.

TVA (default): Engineering report, input required for the governing analysis.
Opnameplan: Inspection plan document, input required if soil investigation is required (default True). This report template is used by project support.
Opname: Inspection report, no input required. This report template is used by the inspector of the object.
bkg: Form to be used for requesting scope changes for NCG. Form is used by the projectleader of the object. No additional input required. This is a report in Excel.
Kostenraming: Report template filled with data from MYVIIA to be used by the cost engineer of the object. This is a report in Excel.
crm: Administration form for the client NCG. This report template is used by the editor of the object. No additional input required. This is a report in Excel.
Beoordeling: Final assessment document for the owner, also called EVVA. This report template is used by the editor of the object. Requires no additional input.
UrenMonitor: Excel sheet with an overview of the progress. This report template is used by the projectleader and management.
UO: UO report, no input required. This report template is used by the engineer and lead engineer of the object.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
report_type (str): Select the report to be generated. Default value TVA, creating the engineering report including all of its annexes.
governing_analysis (str): Governing analysis for NLTH results. For NLTH report the governing analysis can be selected from ‘S1’, ‘S2’, ‘S3’, ‘S4’, ‘S5’, ‘S6’, ‘S7’, ‘S8’, ‘S9’, ‘S10’ or ‘S11’. Default value is None, which should be selected for other report-types than the NLTH TVA report.
soil_investigation (bool): Boolean for soil investigation (required for Opnameplan report). If soil investigation is to be done, the value is True. Otherwise, the value is False. Default value is True.
scope_change_id (int): ID of the selected object scope-change in MYVIIA database. Default value is None, only required when the BKG report is created with this function.
werkpakket_lst (list of str): List of names of the werkpakket to create the Excel for. Default value is None, only required when the uren monitor report is created with this function.
extra_object_parts (list of str): List of names of extra object parts to include in the report. Default value is None, only required when the UO report is created with this function.
output_folder (Path): Optional input for location where to create the report. Default value is None, indicating the default location is used. In normal production objects do not change this!
images_folder (Path): Optional input for location where to store the images for the report. Default value is None, indicating the default location is used. In normal production objects do not change this!
input_folders (dict): Dictionary with the folders where the results of the analyses should be collected from. Default value None. Input is only required for the engineering report of NLTH assessment.

Output:

The requested report is generated with the information of the object in py-memory, databases and local (image-) files. It is saved in sub-folder of the working folder, depending on the type of report. The user is notified where the document is created.
Returns list of files created for the report type selected.

viia_create_response_spectra()

Function to get the parameters of the response spectrum from the NEN-webtool for the response spectra of the NPR9998. The response spectrum is created in the class ‘ResponseSpectrum’.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

The response spectrum objects are created for all return periods and all directions for the location as defined in the Project class.

viia_create_roof(name: Union[str, Layer], material: str, geometry: str, points: List[List[List[Union[float, str, Shapes, Level]]]], element_x_axis: Optional[Union[List[float], str]] = None) → Roof

VIIA function to create a roof shape based on layer, material, geometry and contour points. The points list can also contain the openings in the roof shape.

Warning

In this release a string containing the full name is still accepted as input for name. In future releases this functionality will be deprecated. Enter a layer object instead.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
name (str or Layer): Name of the layer as a string, or the Layer object itself, to which the newly created roof should be added. Full name of shape is also accepted, not applying auto naming function, this will be removed in future releases.
material (str): Name of the material of the roof shape to be created, complying VIIA naming convention.
geometry (str): Name of the geometry of the roof shape to be created, complying VIIA naming convention. If naming convention dictates that the geometry is incorporated into the material (e.g. wood plank roofs), setting the geometry to 0 skips the geometry parameter when generating the object name.
points (list of list of list of floats and shapes): The points of the contour and opening of the roof shape. Each point is a list of 3 floats or 2 floats and 1 shape. If 3 floats are given, the unmodified point is used. If 2 floats and 1 shape is given, the unknown coordinate at the index of the shape is calculated by projection on this shape. Shapes can be inputted as objects or strings. e.g. [[[0, 0, 0], [1, 0, 0], [1, “wall_1”, 0], [0, wall_1, 0]], [coordinates of opening1], [coordinates of opening2] etc.]. The z-coordinate can also be provided as level object, or name of the level.
element_x_axis (list of floats): Optional input to define direction of the local x-axis of the roof, which also defines the spanning direction of the roof. Default value is None, in which case the element-x-axis is set to the direction of the intersection of the surface with a horizontal plane. In case of a roof (with a horizontal surface), the local x-axis is set in the global x-direction.

Output:

Returns the created roof object reference.
The roof is added to the project and to the layer.

viia_create_supports(support_type: str = 'FixedBase', material_file: Optional[Union[str, Path]] = None, material_dictionary: Optional[Dict[Union[str, Path], List[Surfaces]]] = None, excluded_supported_surfaces: Optional[List[Fstrip]] = None, additional_supported_shapes: Optional[List[Union[Floor, Wall, Fstrip, Beam, Column, Points]]] = None)

Function to create the shallow foundation supports. The shallow foundation can be modelled for fixed-base or flexbase. It will apply the supports to the foundation strips in the model. Additional supported surfaces can be supported by providing those in a list, and foundation strips can be excluded (if there is a mixed foundation for example where there are piles connecting to certain foundation strips).

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
support_type (str): Type of shallow foundation, available are ‘FixedBase’, ‘FlexBaseGlobal’ and ‘FlexBaseFinal’. Default value is ‘FixedBase’.
material_file (str): Name of the dat-file for the flexbase, the dat-file will be provided by the geotechnical engineer. It should be located in the workfolder and is only required in case of ‘FlexBaseGlobal’, or might be required for ‘FlexBaseFinal’. In case of ‘FlexBaseFinal’ it is assumed that this material should be applied on all supported surfaces, otherwise provide the material-dictionary instead. Default value is None. Alternative (path): The full path to the file can also be provided, the file location is then not required to be in the workfolder (still this is the suggested location).
material_dictionary (dict): Dictionary with the material properties for the ‘FlexBaseFinal’ supports. In this case multiple material files can be provided and supported surfaces should be linked to the material that should be applied on that support.
excluded_supported_surfaces (list with obj): List with object references or names of shapes which have to be excluded from the supported shapes list (not required). Default input is None, no foundation strips are excluded.
additional_supported_shapes (list with obj): List with object references of shapes which have to be supported in addition to shapes of class ‘Fstrip’ (not required). Default input is None, no shapes are added.

Output:

The supports are created according the requirements for the phase.

viia_create_surface_mass_floor(floor: Floor, resting_load: Optional[List[str]] = None, category: str = None, extra_load: float = 0.0)

This function applies floor loads. The load is added by adjusting self weight of the floor. Geometry with different loads and/or functions should be separated into more geometries

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
floor (obj): Object reference to the floor on which the load is applied. Alternative(str): Name of the floor.
resting_load (list with strings): List with the resting loads to be applied. Default value is None, in which case no resting loads are applied.
category (str): name of the category of variable load to be applied
extra_load (float): Optional input to apply a user defined load. Default value is 0.0, value of the additional (non-programmed) loads in the seismic situation, in [N/m2].

Category can be (only one category can be chosen): ‘AFloor’, ‘AStairs’, ABalc’, ‘BOffice’, ‘CSchool’, ‘C1_2’, ‘C3_5’, ‘DShop’, ‘E’, ‘F’, ‘HRoof’.

Rest can contain: ‘WindowLoad’, ‘FinishLoad’, ‘CeilingLoad’, ‘WallLoad’, ‘WallLoadLight’, ‘WallLoadMedium’, ‘WallLoadHeavy’, ‘InstalLoad’, ‘FlatRoofLoad’,’FlatRoofGravelLoad’, ‘SlopeRoofLoad’, ‘SlopeRoofLoadConcrete’, ‘SlopeRoofLoadClay’,’SunPanelLoad’.

Output:

Material of the floor is changed to a new material with increased density to take into account the extra load.

viia_create_surface_mass_wall(wall, extra_load)

Function to apply wall loads (e.g. cladding or cavity walls). Geometry with different loads and/or functions should be seperated into more geometries. Load is added by adjusting self weight of wall.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
wall (obj): Object reference to the wall on which the load is applied. Alternative(str): Name of the wall.
extra_load (float): Added weight, in [N/m2].

Output:

Material of the wall is changed to a new material with increased density to take into account the extra load.

viia_create_tying(source: Union[Surfaces, Lines, str], target: Union[Surfaces, Lines, str], source_node: Optional[Node] = None, target_node: Optional[Node] = None, degrees_of_freedom: Optional[List[List[float]]] = None, axes: Optional[List[Union[str, int, Direction]]] = None) → List[Tying]

Function to connect two shapes with a tying. This is not a default approach in the VIIA workflow, but can be applied in specific situations after consultation with the lead engineer. This function needs to be used to comply to the naming convention, which is used in the phasing and result handling.

Note

Before using this function make sure the two shapes are connected (only in case you want to apply a tying on a coinciding node). For this the project.viia_connect_shape function can be used.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
source (obj): Object reference of source shape. This might be a surface or line-shape and depends on the requested detail. Alternative (str): The name of the source shape can be provided.
target (obj): Object reference of target shape. This might be a surface or line-shape and depends on the requested detail. Alternative (str): The name of the target shape can be provided.
source_node (obj): Object reference of source node for the tying. Default value is None, in which case the source node is retrieved based on the other inputs. For example if the shapes are connecting with a shared node or nodes, these nodes can be found automatically.
target_node (obj): Object reference of target node for the tying. Default value is None, in which case the target node is retrieved based on the other inputs (see also source node).
degrees_of_freedom (list of 2 lists with 3 integers): Lists with the translational and rotational degrees of freedom to be tied. The first list contains the translational degrees of freedom in the local x-, y- and z-axes. The second list contains the rotational degrees of freedom or rotation about the local x-, y- and z-axes. Default value is [[0, 0, 0], [1, 1, 1]].
axes (list of obj): List defining the local axes. The directions in the list are instances of the Direction class. The length of the list should be three in the order of local x, y, z-direction. Default value is None, which will generate default directions depending on connection type (point, line or surface connection).

Output:

Returns the created tying.

viia_create_wall(name: Union[str, Layer], material: str, geometry: str, points: List[List[List[Union[float, str, Shapes, Level]]]], cavity_inner_wall_id: Optional[int] = None, structural_type: str = 'psse') → Wall

VIIA function to create a wall shape based on naming convention for shape, material, geometry and contour points. The points list can also contain the openings in the wall shape.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
name (str or Layer): Name of the layer as a string, or the Layer object itself, to which the newly created column should be added. Full name of shape is also accepted, not applying auto naming function, this will be removed in future releases.
material (str): Name of the material of the wall shape to be created, complying VIIA naming convention.
geometry (str): Name of the geometry of the wall shape to be created, complying VIIA naming convention.
points (list of list of floats and shapes): The points of the contour and opening of the wall shape. Each point is a list of 3 floats or 2 floats and 1 shape. If 3 floats are given, the unmodified point is used. If 2 floats and 1 shape is given, the unknown coordinate at the index of the shape is calculated by projection on this shape. Shapes can be inputted as objects or strings. e.g. [[[0, 0, 0], [1, 0, 0], [1, “wall_1”, 0], [0, wall_1, 0]], [coordinates of opening1], [coordinates of opening2] etc.]. The z-coordinate can also be provided as level object, or name of the level.
cavity_inner_wall_id (int): In case of an outer leaf of a cavity wall, the ID will be set based on the ID of the inner leaf. This number should be provided in that case.
structural_type (str): Optional structural type, can be either ‘psse’ or ‘nsce’.

Output:

Returns the created wall object reference. The ID of the newly created wall is set to the number supplied in the name. For cavity walls, 9000 is added to the id that is supplied. Therefore, if the inner leaf has id = 5, the outer leaf will have id = 9005.
The wall is added to the project and to the layer.

viia_create_wall_ties_on_line(inner_leaf: Wall, outer_leaf: Wall, inner_line: List[List[float]], outer_line: List[List[Union[float, int]]], wall_tie_distance: Optional[float] = 0.5, snap_to_points: bool = True, minimum_distance: Optional[float] = 0.25)

This function will create wall ties between the provided inner and outer leaf, along the required line.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

inner_leaf (obj): Object reference of the inner leaf of the cavity wall.

outer_leaf (obj): Object reference of the outer leaf of the cavity wall.

inner_line (list of list of float): Line on the inner leaf on which the wall ties are applied.

outer_line (list of list of float): Line on the outer leaf on which the wall ties are applied.

wall_tie_distance (float): Distance between ties, in [m]. Default value is 0.5 m.

snap_to_points (bool): Toggle for snapping to nearby points. Default value is True.

minimum_distance (float): Minimum distance to snap to nearby points. Default value is 0.25 m.

Output:

Returns list of newly created cavity wall ties.

viia_create_walls_on_grid(layer: Union[str, Layer], z_bottom: float, z_top: float, wall_list: List[List[Union[str, int]]], grid: Optional[Union[Grid, int, str]] = None, structural_type: str = 'psse') → List[Wall]

This function is used to set up the walls for a specific layer, making use of a grid system. A wall list is given as input, in which each row represents a wall. Each wall is in turn represented by a list of four values; starting point, end point, material and thickness. The points to place the wall should be given in grid notation, for instance ‘A3’.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
layer (str): String specifying the layer, conform VIIA naming convention. For example: ‘N0’.
z_bottom (float): The z_coordinate of the bottom of the wall, in [m].
z_top (float): The z_coordinate of the top of the wall, in [m].
wall_list (list): List containing the information of the individual walls, for example [[‘D1’, ‘D9’, ‘MW-KLEI<1945’, 210], [‘D9’, ‘L9’, ‘MW-KLEI<1945’, 210],[[0,0], [7.5,0], ‘MW-KLEI<1945’, 210]]. This will create masonry wall with a thickness of 210mm between grid point D1 and D9, a second wall between grid-points D9 and L9 and third wall between coordinates [0,0] and [7.5,0].
grid (Grid, int, str): Optional object, id or name of the grid to use. By default, the first grid in the collection is used.
is_foundationwalls (bool): Optional boolean to create foundation walls. Default set to False.
structural_type (str): Optional structural type, can be either ‘psse’ or ‘nsce’.

Output:

Each wall described in the wall list is added to the project and the relevant collections.
A list containing all wall objects is returned.

Example:

project.viia_create_walls_on_grid(
    layer='N0', z_coordinate_bottom=0.0, z_coordinate_top=3.0,
    wall_list=[['D1', 'D9', 'MW-KLEI<1945', 210], ['D9', 'L9', 'MW-KLEI<1945', 210],
    [[0,0], [7.5,0], 'MW-KLEI<1945', 210]])

viia_demand_curve(spectr_red_fac=1.0, return_period=2475, steps=100)

This is function is to create the seismic demand curve for push over analysis. The corresponding theory and procedure can be found in NLPO protocol assessment section 3. If the adress of the object is set priorly, the function is able to collect preparatory data from the NEN webtool.

Input:

project (obj): ViiaProject object containing collections and of fem objects and project variables.
spectr_red_fac (float): spectral reduction factor associated with the system damping
return_period (int): the prescribed return period associated with the demand spectrum in years
steps (int): discrete points that control the smoothness of the figure

Output:

dictionary that contains the (in)/elastic displacement/accelertion response spectrum value
dictionary with associated spectrum parameters

Attribute:

viia_demand_curve.get_value_ADR

return a dict containing the (in)/elastic disp/acceleration spectrum value on period t

>> data = viia_demand_curve(response_spectrum_file) >> data_at_random_time = viia_demand_curve.get_value_ADR(t=0.5) >> data_at_random_time = {‘se’: 0.521809934,

‘sDe’: 32.38312009139122, ‘sen’: 0.29434049937163764, ‘sDen’: 18.266543271504304}

viia_disconnect_shape(shape: Shapes, shapes_to_exclude: List[Union[Shapes, str]] = None)

Function to apply NOCON connections to all connecting shapes.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
shape (obj): Shape that need to be disconnect from other shapes
shapes_to_exclude (list of str/obj): List with shapes that should stay connected to the shape. Can be given as name of the shape or object reference. Default is None.

Output:

The connections that are made

viia_extend_wall_to_wall_horizontal(wall: Wall, target_wall: Wall)

Function to extend a wall to another wall.

Warning

Walls must be vertical surface, and no openings on the line that will be extended.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
wall (obj): Object reference for Wall object that needs to be extended.
target_wall (obj): Object reference for Wall object that is the target surface for the wall to be extended to.

Output:

The wall is extended to the target wall.

viia_find_floor_mesh_nodes() → Dict

This function finds all the nodes within the floors of the model.

Warning

The model must be meshed, the dat-file should have been created and the dat-file should have been read and converted to DATDict, the dictionary containing the information in the dat-file.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Returns a dictionary with storey numbers (N0, N1, etc.) as keys with lists of corresponding floor node numbers of that storey as values.

viia_find_foundation_nodes_under_wall(node_fstrip_list: List[int], wall_name: str) → Union[List[int], None]

This function will look for the closest node of the foundation strips in the mesh to the point in the bottom line of the given wall. The z-coordinate of the bottom line is determined by the smallest z-coordinate of the contour of the wall. The function will loop through the nodes on foundation strip to check whether the nodes are under this wall.

Warning

The model must be meshed, the dat-file should have been created and the dat-file should have been read and converted to DATDict, the dictionary containing the information in the dat-file.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
node_fstrip_list (list of int): A list of the all the node numbers in the foundation strips
wall_name(str): Name of the requested wall.

Output:

Returns a list with multiple nodes (integers).

viia_find_foundation_strip_below_wall() → Optional[Fstrip]

This function will get the underlying foundation strip of a certain wall by check if the intersection exists from the center of the wall pointing to the foundation strip.

Input:

wall (obj): Wall object.

Output:

Returns the foundation strip object below the wall.

viia_find_intersecting_floors_for_wall(wall)

This function will get the intersecting floors of a wall by the following two steps: First check if both points of a line of the wall are in the surface of the floor. Else check if both points of a line of the floor are in the surface of the wall.

Note

Make sure the shapes are properly connected using the connect_shape function.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
wall: Wall object.

Output:

Returns a list of the intersecting floors of the wall.

viia_find_lower_floor_of_wall()

This function will get the lower intersecting floors of a wall by using the function of viia_find_intersecting_floors_for_wall, the method here to judge if it is a lower floor is to compare the floor z_coordinate with the center of the wall coordinate.

Input:

wall: Wall object.

Output:

Returns a list of the lower intersecting floors of the wall.

viia_find_max_name_number(collection, select_foundationwalls: bool = False) → int

Function that finds the highest number that is used in the name of objects within a specified collection. The number that is returned is an integer.

Input:

project (obj): Project object containing collections and of fem objects and project variables.
collection (list with object references): List of the objects for which the name number will be checked.
select_foundationwalls (bool): Optional parameter to find foundation walls.

Output:

Returns the highest integer found in the names of objects in the collection.

viia_find_nodes_top_ridge(tolerance=0.001) → List[MeshNode]

This function collects the top mesh-nodes (in z-coordinate) within floor and roof shapes. The maximum z-coordinate is determined and any nodes within the tolerated distance from this maximum plane are collected.

Warning

The model must be meshed and read into the project. For diana this is done with project.from_diana.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
tolerance (float): the tolerated distance from the found maximum z-coordinate

Output:

Returns a list with MeshNode objects.

viia_find_top_wall(wall: Wall)

Finds the top wall connected to the given wall in the project.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
wall: The wall to find the top wall for.

Output:

The top wall if found, otherwise None.

viia_find_upper_floor_of_wall() → List[Floor]

This function will get the upper intersecting floors of a wall by using the function of viia_find_intersecting_floors_for_wall, the method here to judge if it is an upper floor is to compare the floor z_coordinate with the center of the wall coordinate.

Input:

wall (obj): Wall object.

Output:

Returns a list of the upper intersecting floors of the wall.

viia_find_wall_groups_for_nlka_in_model() → Dict

This function will look for all the walls in the model, group them with the required parameters in the NLKA assessment procedure.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

A dictionary is returned, which contains all the wall groups and all required parameters for nlka assessment. It also includes all the wall names in the group.

viia_find_wall_overburden_load(walls: Optional[List[Wall]] = None, load_case: Optional[str] = None, steps=50, view: list = None)

This function creates the overburden load for the walls in input list as their attribute, it is only applicable for rectangular walls at this stage.

Input:

project (obj): Project object containing collections and of fem objects and project variables.
walls (list of obj.): The selected wall objects. If none are given, all walls are selected.
load_case (str): The load-case selected from the analysis.
steps (int): Number of segments for the probe curve. Default value is 50. Creates 50 sample points.
view (list of 2 str): default arguments, specifically, for example: [‘Distributed Forces/mappedintpnt’, ‘Nyy’] for the purpose of calculating the overburden load.

Output:

All rectangular wall objects have an additional attribute for the overburden load. If overburden load is >0, it is set to 0 (wall cannot be in tension under self weight).
An Excel is created in the workfolder with the wall names and overburden loads.

viia_forces_l2_measures(json: Path, tb_4a_file: Path) → Path

This function can be used to obtain the maximum and minimum forces in L2 measures (interfaces). The output produces an Excel sheet with a summary of the maximum and minimum forces per interface.

Input:

project (obj): Project object reference containing collections of fem objects and project variables.
json_file (Path): Path to the location of the json-file including the analysis.
tb_file (Path): Path to the location of the tb-file which contains the results of the stresses in the interfaces from output 4 in the NLTH analysis.

Output:

Creates an Excel sheet with a summary of the maximum and minimum forces in the interfaces for strengthening measures L2.
Returns the path of the Excel-file.

viia_foundation_area() → Tuple[Optional[float], Optional[int]]

Function calculates the foundation area of the foundation strips from the generated dat-file.

Input:

project (obj): Project object containing collections and of fem objects and project variables.

Output:

Returns the two values as tuple. First value is the area of shallow foundation in the model (supported surfaces), in [m2] and the second value is the number of piles. If one is not present it will return None instead.

viia_geometries(geometry_name: str) → Geometry

This function will collect the arguments for the creation of an object based on the name of the element geometry. The VIIA naming convention is applied in this function and sub-functions it uses.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
geometry_name(str): Name of the element geometry.

Output:

Returns the object reference to the ‘Geometry’ object that is created based on the input arguments.

viia_get(collection: Optional[str] = 'all', name: Optional[str] = None, id: Optional[int] = None, unique_id: Optional[str] = None)

This function will return the object with the name that is provided.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
collection (str): Name of the collection of shapes to look in. Default set to all collections present in the project instance.
name (str): Name that will be used for searching.
id (int): ID that will be used for searching.
unique_id (str): Unique-ID that will be used for searching.

Output:

Returns the object with the provided name. If no object fulfills the requirements, None will be returned.

viia_get_connection(collection_name: Optional[str] = 'all', name: Optional[str] = None, _id: Optional[int] = None, point: Optional[List[float]] = None) → Optional[Connections]

This function can be used to find a connection based on some queries from user. It will return the connection object. In case multiple conections comply to the query, the first connection is returned and a warning is printed.

The user can provide a name or ID of the connection. The connection with this name or ID is returned. Note that in case of ID the input for the collections should be narrowed.

The user can provide a point (x-, y- and z-coordinate as list). In this case, the function will return the connection for which the point is on the node, line or surface of the connection. Alternative input can be object reference of Node.

Note

Finding connections is not available for volume-shapes with connections applied.

Input:

project (obj): Project object reference containing collections of fem objects and project variables.
collection_name (str): Name of the collection of connections to look in. Default set to all collections for connections present in the project instance.
name (str): Name that will be used for searching, this may be a part of the name too. Function is not case-sensitive. Default value is None, in which case it is not checking for name.
_id (int): ID that will be used for searching. Default value is None, in which case it is not checking for ID.
point (list of 3 floats): List of the x-, y- and z-coordinates of the point to be used for searching, values in [m]. Default value is None, in which case it is not checking for point. Alternative input object reference of Node.

Output:

Returns the connection object from the requested collection, filtered for the requested layer if any, filtered for the connections that comply to the requested inputs. If no connection is found, None is returned. If multiple connections have been found, the first one is returned. The user is notified of this.

viia_get_drift_limits(com_list_per_storey: List[float], category: str = 'Ductile')

This function obtains the drift limits of a SDoF system equivalent according to the NPR for NLPO.

Input:

project (obj): ViiaProject object containing collections and of fem objects and project variables.
com_list_per_storey (list): list with names of subsystems to process

Output:

Data is added to project.project_specific[‘drift_limits’]

viia_get_facades()

Function returns and prints list of facade walls, based on VIIA functions. This function should be used to check and if required manually update list to use in consecutive functions for cost engineer. The function makes use of the viia_check_inner_wall functionality.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Returns and prints the facade shapes as list.

viia_get_file(path: Path, starts_with: Optional[str] = None, in_name: Optional[str] = None, suffix: Optional[str] = None)

Function to find project files in a specified path, based on file name or extension.

Input:

project (obj): Project object containing collections and of fem objects and project variables.
path (Path): Path in which the function should check for the file.
starts_with (str): String with which the file name should start in order to be eligible.
in_name (str): String with which the file name should start in order to be eligible.
suffix (str): String describing the suffix/file-extension which the file should contain in order to be eligible.

Output:

File in path that satisfies the inputted search criteria.

viia_get_flat_roofs() → List[Roof]

This function collects all the flat roofs. It loops only through the roof object collection and checks if the normal vector of the contour of the roof is vertical.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

List with all the object references of flat roofs.

viia_get_highest_layer(layer1: Layer, layer2: Layer, name: bool = False) → Union[Layer, str]

This function determines the highest layer of the two layers received, following VIIA naming convention.

Input:

name (bool): Optional input to get the name of that layer. Default value False, returning the layer object.

Output:

Returns the highest layer or name of the requested layer objects.

viia_get_inner_walls()

Function returns and prints list of inner walls, based on VIIA functions. This function should be used to check and if required manually update list to use in consecutive functions for cost engineer. The function makes use of the viia_check_inner_wall functionality.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Returns and prints the inner wall shapes as list.

viia_get_latest_model_folder(version: Optional[Union[int, str]] = None, folder: Optional[Path] = None, analysis_nr: Optional[str] = None, signal: Optional[str] = None) → Optional[Path]

This function selects the latest model from the default analysis sub-folders. The path is based on the latest version and time an in the name of the folder. The version number determines the required model step. For BSC, the version is always 1. For TVA, the specific step must be provided. Within this selection the latest timestamp in the folder name is used to find the folder.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
version (int): The version number as indicated at start of the project. By VIIA convention version number 1 indicates the BSC and higher numbers the strengthening steps. To get the latest model folder with the highest version number, provide input ‘highest’. Default value is None, using the version specified in the project.
folder (path): The path of the folder containing the folders from which the latest result folder must be obtained.
analysis_nr (str): The name of the analysis referencing the numbers in the viiaStatus. For example ‘A1’.
signal (str): The signal number specified as a string. The available signals are S1, S2, S3, S4, S5, S6, S7, S8, S9, S10 and S11. Required if analysis_name is ‘A4’, ‘A12’ or ‘A15’ or if the folder provided corresponds to one of these three analyses.

Output:

The latest result folder for the specified version number is returned as path reference.

viia_get_layers(names: bool = False) → Union[List[Layer], List[str]]

This function gets the layers from the project and orders them following the VIIA naming convention. Layers start with the foundation (layer ‘F’), basements in reverse order (the deepest one has the highest number), (layer ‘B2’, ‘B1’), and the normal building layers starting with the ground floor (layer ‘N0’, ‘N1’ etc.).

Input:

names (bool): Optional input to get the names of the layers in the list. Default value False, returning a list with the layer objects ordered.

Output:

Returns list of layers ordered for VIIA from bottom up as list of layer objects or layer names.

viia_get_level(shape: Shapes) → Optional[Level]

Function to return the level of the shape. This is based on the VIIA naming convention.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
shape (obj): Shape of which the level is returned.

Output:

Returns the level of the shape as a string, for example ‘N0’.

viia_get_material(material_name: str, material_group: str) → Optional[Dict]

This function will return a dictionary with the material properties from the VIIA-Database-Materials.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
material_name (str): Name of the material that is looked up in the material database.
material_group (str): Name of the group to which the material belongs.

Output:

Returns dictionary with the properties of the material from the database.

viia_get_nsce(object_type: Optional[Type[Shapes]] = None) → List[Shapes]

Gets all shapes from the collections that are NSCE. Optionally a type can be specified like Wall, Column, to only obtain shapes of that type.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
object_type (list of obj): Optional input for selecting type of shape.

Output:

Returns a list of shapes that are classified NSCE, filtered for the requested object-type.

viia_get_preselection_reference_approach(material_load_walls: str, most_floor_height: float, most_thickness_load_walls: float, nr_levels: int, other_floors_material: str, extend_object_data: int = 15, output_folder: Optional[Path] = None, send_to_myviia: bool = False) → Path

This function is used to collect data from the engineering database of MYVIIA and return the most optimal available objects to be referenced as a pre-selection. The references are weighed based on some parameters that are believed to select for the best reference objects.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
material_load_walls (str): Provide the material of the load-bearing walls for which the reference objects are matched. Select from ‘aerated concrete’, ‘concrete’, ‘clay masonry < 1945’, ‘clay masonry > 1945’, ‘calcium silicate > 1960’, ‘calcium silicate > 1985’, ‘HSB’, ‘modification wall’ or ‘timber’.
most_floor_height (float): Most common height of the load-bearing walls for which the reference objects are matched, in [m]. This is the most common floor height (approx.) or in absence of a common height the maximum wall height at the ground level. If we have 4 floors with heights: 3, 3.19, 3.2, 2.7m, the most common floor height is 3.2m. If we have 4 floors with all different height: 3, 3.2, 3.5, 2.7, then the most common floor height is the height of the ground floor.
most_thickness_load_walls (float): Most common thickness of the load-bearing walls for which the reference objects are matched, in [mm]. For PSSEs walls if existing. Usually, the thickness of masonry PSSE is constant between floors but if not select the most common at the ground floor level.
nr_levels (int): Number of levels excluding the basement level and including storage/living area attics. A basement level is included if it covers all the footprint area of the object (excluding appendances) and is modelled for the analysis. Small attic with non-structural ceiling (so no storage/living area) is not considered as a level.
other_floors_material (str): Provide only the most dominant material for the floor materials, other than the ground floor, for which the reference objects are matched. Select from ‘concrete’, ‘masonry’, ‘timber’ or ‘other (structural)’.
extend_object_data (int): Optional input for defining the amount of (best-fitting) objects that get extended information. Extended information includes measures, cost estimate and overview pictures. Default value is 15. Increasing this value will have issues for performance.
output_folder (Path): Optional input for location where to create the report. Default value is None, indicating the default location is used. In normal production objects do not change this!
send_to_myviia (bool): Select if the top 5 objects should be prefilled in the MYVIIA webtool. Default value is False, not sending data to MYVIIA.

Output:

The best 10 matching reference objects are provided for the user as a pre-selection to be used further in the process of the reference approach.

viia_get_psse(object_type: Optional[Type[Shapes]] = None) → List[Shapes]

Gets all shapes from the collections that are PSSE. Optionally a type can be specified like Wall, Column, to only obtain shapes of that type.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
object_type (list of obj): Optional input for selecting type of shape.

Output:

Returns a list of shapes that are classified PSSE, filtered for the requested object-type.

viia_get_scripts_in_folder(file: [str], folder: Optional[Path] = None)

This function returns a file that is saved within a folder as path references.

Input:

project (obj): Project object containing collections and of fem objects and project variables.
file (str): Contains the file name of the script that is required.
folder(Path): Directory from where the scripts should be retrieved.

Output:

The file is returned as path reference.

viia_get_shape(collection_name: Optional[str] = 'all', name: Optional[str] = None, _id: Optional[int] = None, point: Optional[List[float]] = None, gridline: Optional[Union[Gridline, str]] = None, grid: Optional[Union[Grid, str]] = None, level: Optional[Union[Level, str]] = None, layer: Optional[Union[Layer, str]] = None) → Optional[Shapes]

This function can be used to find a shape based on some queries from user. It will return a shape object. In case multiple shapes comply to the query, the first shape is returned and a warning is printed.

The user can provide a name or ID of the shape. The shape with this name or ID is returned.

The user can provide a point (x-, y- and z-coordinate as list). In this case, the function will return the shape for which the point is within the surface of the surface-shape (excluding the openings), the point is on the line of a line-shape or if the coordinate is the point of the point-shape.

The user can also provide a gridline. In this case, the function will return the shape for which the gridline is aligned (vertically) and on the surface plane if it is a surface-shape, the shape is parallel to and on the gridline if it is a line-shape, or the point-shape if the point is on the vertical plane of the gridline.

The user can also provide a level. In this case, the function will return a shape on the level (horizontally).

Different queries can be combined to filter on multiple inputs at the same time.

Note

Finding shape based on the gridline, level or coordinate is not available for volume-shapes.

Input:

project (obj): Project object reference containing collections of fem objects and project variables.
collection_name (str): Name of the collection of shapes to look in. Default set to all collections present in the project instance.
name (str): Name that will be used for searching, this may be a part of the name too. Function is not case-sensitive. Default value is None, in which case it is not checking for name.
_id (int): ID that will be used for searching. Default value is None, in which case it is not checking for ID.
point (list of 3 floats): List of the x-, y- and z-coordinates of the point to be used for searching, values in [m]. Default value is None, in which case it is not checking for point.
gridline (obj or str): Object reference or name of the gridline, specifying the vertical plane in which the shape is searched. In case the gridline is specified as string, the grid should be provided too. This function then will check the gridlines of that grid. Default value is None, in which case it is not checking for gridline.
grid (obj or str): Object reference or name of the grid. The grid is only required if the gridline is specified as string. In that case the grid should contain the required gridline. In any other situation input for the grid is ignored. Default value is None.
level (obj or str): Object reference or name of the level, specifying the horizontal plane in which the shape is searched. Default value is None, in which case it is not checking for level.
layer (obj or str): Object reference or the name of the layer in which to search for the requested shape.

Output:

Returns the shape object from the requested collection, filtered for the requested layer if any, filtered for the shapes that comply to the requested inputs. If no shape is found, None is returned. If multiple shapes have been found, the first one is returned. The user is notified of this.

viia_get_signal(signal) → Optional[Tuple]

This function will return four lists containing the data from the input signals from the VIIA-Database-Signals.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
signal (str): Name of the signal, for example ‘S1’.

Output:

Returns 4 lists as tuple, containing respectively: time-signal, accelerations in x-direction, accelerations in y-direction and accelerations in z-direction.

viia_get_subfolder_in_folder(subfolder: [str], folder: Optional[Path] = None)

This function returns a subfolder that is saved within a folder as path references.

Input:

project (obj): Project object containing collections and of fem objects and project variables.
subfolder(str): Contains the name of the subfolder that is required.
folder(Path): Directory from where the subfolders should be retrieved.

Output:

The subfolder is returned as path reference.

viia_get_top_layer(name: bool = False) → Union[Layer, str]

This function determines the top layer of the structure, following VIIA naming convention.

Input:

name (bool): Optional input to get the name of the layer. Default value False, returning the layer object.

Output:

Returns the top layer of the building as layer object or the name of that layer as string.

viia_get_total_cavity_wall_width(leaf_1: Wall, leaf_2: Wall) → float

This function calculates the total width of the cavity wall. This is the thickness of the inner leaf plus the cavity plus the thickness of the outer leaf.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
leaf_1 (Wall): One leaf of the cavity wall
leaf_2 (Wall): The other leaf of the cavity wall

Output:

Returns the total width of the cavity wall, in [m].

viia_get_weight_of_elements_in_box(x_boundary, y_boundary, z_boundary)

This function will calculate the weight of all the elements in a box by summing the weight of all elements.

Warning

The model must be meshed, the dat-file should have been created and the dat-file should have been read and converted to DATDict, the dictionary containing the information in the dat-file.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
dat: dat file of the model.
x_boundary: list containing the x-boundaries of the box [start-coordinate, end-coordinate]
y_boundary: list containing the y-boundaries of the box [start-coordinate, end-coordinate]
z_boundary: list containing the z-boundaries of the box [start-coordinate, end-coordinate]

Output:

Returns the weight of all the elements in the defined unit in dat file.

viia_include_outerleaf_in_innerleaf_density(wall, thickness_outerleaf, material_outerleaf=None)

Function to take into account the mass of the outer leaf of the cavity wall by adding it to the self weight of the inner leaf of the cavity wall. This function is based on viiaCreateInnerleafDensity(WallName, ExtraLoad) and determines the ExtraLoad out of the outer leaf properties.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
wall (obj): Object reference of the wall (inner leaf) of which the density will be increased. Alternative (str): Name of the wall (inner leaf) of which the density will be increased.
thickness_outerleaf (float): Thickness of the outer wall in [m], i.e.: 0.1 (without quotation marks).
material_outerleaf (str): Material of the outer leaf, not required: if left empty the same material as the inner wall will be applied, i.e.: ‘MW-KLEI>1945’.

Output:

Material of the inner wall is changed to a new material with increased density to take into account the outer leaf.

viia_l2_002(variant: int, interface: Union[str, Interface] = None, shape_1: Union[str, Wall] = None, shape_2: Union[str, Floor, Wall] = None) → Interface

This function creates an L2-002-measure. It can create an interface in between a wall and a floor, or make an existing interface linear.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
interface (str or obj): The interface that has to be made linear. Both the name or object reference can be provided. Default is None, in this case shape_1 and shape_2 should be provided.
shape_1 (str or obj): The object reference or name of the wall to what the interface should be applied. Default is None, in this case the interface should be provided.
shape_2 (str or obj): The object reference or name of the floor or wall to what the interface should be applied. Default is None, in this case the interface should be provided.

Output:

The strengthening measure is added between shape_1 and shape_2 or the interface is made linear.
Returns the interface object reference of the measure.

For example:

To make a linear interface from a non-linear interface, the following input can be used:
>>> project.viia_l2_002(interface='name_of_interface')
To make a new linear interface between two shapes, the following input can be used:
>>> project.viia_l2_002(shape_1='name_of_first_shape', shape_2='name_of_second_shape')

viia_l2_005(interface: Union[str, Interface] = None, shape_1: Union[str, Wall] = None, shape_2: Union[str, Floor] = None, variant: int = 1) → Interface

This function creates an L2-005-measure. It can create an interface in between a wall and a floor, or make an existing interface linear.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
interface (str or obj): The interface that has to be made linear. Both the name or object reference can be provided. Default is None, in this case shape_1 and shape_2 should be provided.
shape_1 (str or obj): The object reference or name of the wall to what the interface should be applied. Default is None, in this case the interface should be provided.
shape_2 (str or obj): The object reference or name of the floor to what the interface should be applied. Default is None, in this case the interface should be provided.
variant (int): The variant number of the measure that is in the GMC.

Output:

The strengthening measure is added between shape_1 and shape_2 or the interface is made linear.
Returns the interface object reference of the measure.

For example:

To make a linear interface from a non-linear interface, the following input can be used:
>>> project.viia_l2_005(interface='name_of_interface')
To make a new linear interface between two shapes, the following input can be used:
>>> project.viia_l2_005(shape_1='name_of_first_shape', shape_2='name_of_second_shape')

viia_l2_025(interface: Union[str, Interface] = None, shape_1: Union[str, Wall] = None, shape_2: Union[str, Wall] = None, variant: int = 1) → Interface

This function creates an L2-025-measure. It can create an interface in between two walls, or make an existing interface linear.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
interface (str or obj): The interface that has to be made linear. Both the name or object reference can be provided. Default is None, in this case shape_1 and shape_2 should be provided.
shape_1 (str or obj): The object reference or name of the wall to what the interface should be applied. Default is None, in this case the interface should be provided.
shape_2 (str or obj): The object reference or name of the wall to what the interface should be applied. Default is None, in this case the interface should be provided.
variant (int): The variant number of the measure that is in the GMC.

Output:

The strengthening measure is added between shape_1 and shape_2 or the interface is made linear.
Returns the interface object reference of the measure.

For example:

To make a linear interface from a non-linear interface, the following input can be used:
>>> project.viia_l2_025(interface='name_of_interface')
To make a new linear interface between two shapes, the following input can be used:
>>> project.viia_l2_025(shape_1='name_of_first_shape', shape_2='name_of_second_shape')

viia_l2_029(line_object: Union[Column, Beam] = None, name: Optional[Union[str, Layer]] = None, points: List[List[Union[float], Node]] = None, variant: int = 1) → Beam

This function creates an L2-029 measure. It can create an truss between two given points, or make an existing beam/column into a truss.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
line_object (obj): Beam or column that will be changed into a truss.
name (str or Layer): Optional argument to provide name of the layer as a string, or the Layer object itself, to which the newly created truss should be added. If not given, it is extracted from the connected shape(s).
points (list of (nodes or list of floats)): The start and end point of the beam shape. A point is defined by a list of 3 floats. Instead of a list of coordinates, the user can alo provide the node.
variant (int): The variant number of the measure that is in the GMC.

Output:

The strengthening measure is added between two given points, or the already created beam/column is converted into a L2-029 truss.
Returns the line_object after converting it into a truss and adding metadata; or a new truss based on the points provided.

For example:

To make a new L2-029 truss between two points, the following input can be used:

project.viia_l2_029(name=’name of layer, e.g. N0’, points=[[5., 0., 3.5], [5., 2., 4.]])

To make an existing beam/column into an L2-029 truss, the following input can be used:

project.viia_l2_053(line_object=’name_of_beam’)

viia_l2_043(variant: int, interface: Union[str, Interface] = None, shape_1: Union[str, Wall] = None, shape_2: Union[str, Wall] = None) → Interface

This function creates an L2-043-measure. It can create an interface in between two walls, or make an existing interface linear.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
interface (str or obj): The interface that has to be made linear. Both the name or object reference can be provided. Default is None, in this case shape_1 and shape_2 should be provided.
shape_1 (str or obj): The object reference or name of the wall to what the interface should be applied. Default is None, in this case the interface should be provided.
shape_2 (str or obj): The object reference or name of the wall to what the interface should be applied. Default is None, in this case the interface should be provided.

Output:

The strengthening measure is added between shape_1 and shape_2 or the interface is made linear.
Returns the interface object reference of the measure.

For example:

To make a linear interface from a non-linear interface, the following input can be used:
>>> project.viia_l2_043(interface='name_of_interface')
To make a new linear interface between two shapes, the following input can be used:
>>> project.viia_l2_043(shape_1='name_of_first_shape', shape_2='name_of_second_shape')

viia_l2_053(variant: int, connection: Union[str, Interface, NoConnection] = None, shape_1: Union[str, Wall] = None, shape_2: Union[str, Floor] = None) → Interface

This function creates an L2-053-measure. It can create an interface in between a floor and wall, or make an existing interface linear.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
connection (str or obj): The interface that has to be made linear or the NoConnection that should be replaced. Both the name or object reference can be provided. Default is None, in this case shape_1 and shape_2 should be provided.
shape_1 (str or obj): The object reference or name of the wall to what the interface should be applied. Default is None, in this case the interface should be provided.
shape_2 (str or obj): The object reference or name of the floor to what the interface should be applied. Default is None, in this case the interface should be provided.

Output:

The strengthening measure is added between shape_1 and shape_2 or the interface is made linear.
Returns the interface object reference of the measure.

For example:

To make a linear interface from a non-linear interface, the following input can be used:
>>> project.viia_l2_053(interface='name_of_interface')
To make a new linear interface between two shapes, the following input can be used:
>>> project.viia_l2_053(shape_1='name_of_first_shape', shape_2='name_of_second_shape')

viia_l2_054(variant: int, connection: Union[str, Interface, NoConnection] = None, shape_1: Union[str, Wall] = None, shape_2: Union[str, Floor] = None) → Interface

This function creates an L2-054-measure. It can create an interface in between a floor and wall, or make an existing interface linear.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
connection (str or obj): The interface that has to be made linear or the NoConnection that should be replaced. Both the name or object reference can be provided. Default is None, in this case shape_1 and shape_2 should be provided.
shape_1 (str or obj): The object reference or name of the wall to what the interface should be applied. Default is None, in this case the interface should be provided.
shape_2 (str or obj): The object reference or name of the floor to what the interface should be applied. Default is None, in this case the interface should be provided.

Output:

The strengthening measure is added between shape_1 and shape_2 or the interface is made linear.
Returns the interface object reference of the measure.

For example:

To make a linear interface from a non-linear interface, the following input can be used:
>>> project.viia_l2_054(interface='name_of_interface')
To make a new linear interface between two shapes, the following input can be used:
>>> project.viia_l2_054(shape_1='name_of_first_shape', shape_2='name_of_second_shape')

viia_l2_060(interface: Union[str, Interface] = None, shape_1: Union[str, Wall] = None, shape_2: Union[str, Wall] = None, variant: int = 1) → Interface

This function creates an L2-060-measure. It can create an interface in between two walls, or make an existing interface linear.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
interface (str or obj): The interface that has to be made linear. Both the name or object reference can be provided. Default is None, in this case shape_1 and shape_2 should be provided.
shape_1 (str or obj): The object reference or name of the wall to what the interface should be applied. Default is None, in this case the interface should be provided.
shape_2 (str or obj): The object reference or name of the wall to what the interface should be applied. Default is None, in this case the interface should be provided.
variant (int): The variant number of the measure that is in the GMC.

Output:

The strengthening measure is added between shape_1 and shape_2 or the interface is made linear.
Returns the interface object reference of the measure.

For example:

To make a linear interface from a non-linear interface, the following input can be used:
>>> project.viia_l2_060(interface='name_of_interface')
To make a new linear interface between two shapes, the following input can be used:
>>> project.viia_l2_060(shape_1='name_of_first_shape', shape_2='name_of_second_shape')

viia_l3a(variant: int, floor: Union[str, Floor]) → Floor

This function creates an L3-A measure for a selected floor. With this measure, two multiplex panels are glued or screwed onto the existing timber floor. When applied to a timber joist with planks, the strength and stiffness of the planks is neglected. In the FEM-model the material of the floor will be adjusted with an updated material model, mass density and thickness.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant of the measure that is in the GMC.
floor (obj): The object reference of the floor that has to be strengthened. Alternative (str): Name of the floor to be strengthened.

Output:

The strengthening measure is added to the floor.
Returns the floor object reference on which the measure is applied.

viia_l3b(variant: int, floor: Union[str, Floor]) → Floor

This function creates an L3-B-measure for a selected floor. With this measure, two layers of OSB panels (12mm) is glued and screwed underneath the existing roof. In the FEM-model the material of the floor will be adjusted with an updated material model, mass density and thickness.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
floor (obj): The object reference of the floor that has to be strengthened. Alternative (str): Name of the floor to be strengthened.

Output:

The strengthening measure is added to the floor.
When running in DIANA after creating the model, the DIANA model is updated.
Returns the floor object reference on which the measure is applied.

viia_l3d(variant: int, roof: Union[str, Roof]) → Roof

This function creates an L3-D-measure for a selected roof. With this measure, one layer of multiplex panels is glued or screwed onto the existing roof. This is applied from the bottom. It is assumed that the connection is made in such a way that the (shear) capacity of the plates is governing. When applied to a roof surface consisting of a timber joist with planks, the strength and stiffness of the planks is neglected. In the FEM-model the material of the floor will be adjusted with an updated material model, mass density and thickness.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
roof (obj): The object reference of the roof that has to be strengthened. Alternative (str): Name of the roof to be strengthened.

Output:

The strengthening measure is added to the roof.
When running in DIANA after creating the model, the DIANA model is updated.
Returns the roof object reference on which the measure is applied.

viia_l3e(roof: Union[str, Roof], variant: int = 1) → Roof

This function creates an L3-E-measure for a selected roof. With this measure, one layer of multiplex panels is glued or screwed onto the existing roof. This is applied from the top. It is assumed that the connection is made in such a way that the (shear) capacity of the plates is governing. When applied to a roof surface consisting of a timber joist with planks, the strength and stiffness of the planks is neglected. In the FEM-model the material of the floor will be adjusted with an updated material model, mass density and thickness.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
roof (obj): The object reference of the roof that has to be strengthened. Alternative (str): Name of the roof to be strengthened.
variant (int): The variant number of the measure that is in the GMC.

Output:

The strengthening measure is added to the roof.
When running in DIANA after creating the model, the DIANA model is updated.
Returns the roof object reference on which the measure is applied.

viia_l3g(variant: int, name: Union[str, Layer], material: str, geometry: str, points: List[List[Union[float, str, Shapes, Level]]], roof: Optional[Union[str, Roof]] = None)

This function creates an L3-G-measure for a selected roof. With this measure, the roof is strengthened by adding steel bracing. Various steel profiles can be applied. The modelling of this measure is in line with the modelling as described for steel structures in general.

Note

Function will add the strengthening measure data to the roof when provided, otherwise, the data is added to the created steel bracing shape object.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
name (str or Layer): Name of the layer as a string, or the Layer object itself, to which the newly created bracing shape object should be added.
material (str): Name of the material of the bracing shape to be created, complying VIIA naming convention.
geometry (str): Name of the geometry of the bracing shape to be created, complying VIIA naming convention.
points (list of list of floats and shapes): The start and end point of the bracing shape. Each point point is a list of 3 floats or 2 floats and 1 shape. If 3 floats are given, the unmodified point is used. If 2 floats and 1 shape is given, the unknown coordinate at the index of the shape is calculated by projection on this shape. Shapes can be inputted as objects or strings e.g. [[19.2, 6, “roof_1”], [0, 1, 4]] or [[19.2, roof_1, 15], [0, 1, 4]]. The z-coordinate can also be provided as level object, or name of the level.
roof (obj): Object reference of the roof that has to be strengthened. Optional input, if not provided the data about the strengthening measure is stored in the newly added bracing element. Alternative (str): Name of the roof to be strengthened.

Output:

The strengthening measure is added to the roof or the steel bracing.
When running in DIANA after creating the model, the DIANA model is updated.
Returns the newly created truss element as object reference.

viia_l3m(variant: int, roof: Union[str, Roof]) → Roof

This function creates an L3-M-measure for a selected roof. With this measure, one layer of OSB panels is glued or screwed onto the existing roof. In the FEM-model the material of the floor will be adjusted with an updated material model, mass density and thickness.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
roof (obj): The object reference of the roof that has to be strengthened. Alternative (str): Name of the roof to be strengthened.

Output:

The strengthening measure is added to the roof.
When running in DIANA after creating the model, the DIANA model is updated.
Returns the roof object reference on which the measure is applied.

viia_l3s(variant: int, roof: Union[str, Roof]) → Roof

This function creates an L3-S-measure for a selected roof. With this measure, one layer of OSB panels is glued or screwed onto the existing roof. This is applied from the bottom. In the FEM-model the material of the roof will be adjusted with an updated material model, mass density and thickness.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
roof (obj): The object reference of the roof that has to be strengthened. Alternative (str): Name of the roof to be strengthened.

Output:

The strengthening measure is added to the roof.
When running in DIANA after creating the model, the DIANA model is updated.
Returns the roof object reference on which the measure is applied.

viia_l4b(variant: int, wall: Union[Wall, str], offset_bottom: float = 0.1, offset_top: float = 0.1, offset_left: float = 0.1, offset_right: float = 0.1)

This function creates an L4-B-measure for a selected wall. It adds vertical steel columns (generally HEA100) with horizontal steel beams (generally IPE100), including eccentricity. It will model the columns and beams around wall openings with the specified offset. The wall should be vertical, but angled in horizontal plane is okay. Also, the top and bottom do not have to be straight.

Warning

Function is currently not available, it requires updates, please send request to the VIIA automating team.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
wall (obj): The object reference of the wall that has to be strengthened. Alternative (str): Name of the wall to be strengthened.
offset_bottom (float): Not obligatory, default value is 0.1m. This is the offset of the steel beam to the bottom edge of the wall opening in [m].
offset_top (float): Not obligatory, default value is 0.1m. This is the offset of the steel beam to the top edge of the wall opening in [m].
offset_left (float): Not obligatory, default value is 0.1m. This is the offset of the steel column to the left edge of the wall opening in [m].
offset_right (float): Not obligatory, default value is 0.1m. This is the offset of the steel column to the right edge of the wall opening in [m].

Output:

The strengthening measure is added to class of columns and beams and modelled in DIANA or SCIA.

For example:

>>> project.viia_l4b(project, wall, 0.3, 0.2, 0.1, 0)

This example will apply the L4-B measure with vertical steel columns and horizontal steel beams around wall openings, for out-of-plane strengthening of Wall5 with bottom, top, left and right offset of 0.3, 0.2, 0.1 and 0 respectively.

viia_l4d(variant: int, wall, cavity: float = 0.0, outer_wall_thickness: float = None, outer_wall_material: str = None, flip: bool = False, edge_distance: float = 0.25, wall_tie_distance: float = 0.5)

This function creates an L4-D-measure for a selected wall. The purpose of this measure is to fix the outer leaf at the cavity wall to the structural inner leaf with cavity wall ties. The measure is modeled with the same properties as the modelling of existing wall ties.

Warning

Wall ties close to the corners or edges of the wall’s geometry will be moved to the nearby corner or edge. This is done to prevent mesh inconsistencies. Check the final mesh!

Note

Strengthening measure is only applicable on vertical walls.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
wall (as object/str or list of two objects/str): When provided with only one wall object or string, the outer leaf of that wall will be created along with cavity wall ties. When provided with list of 2 wall objects or strings in case the walls are existing in the model, the cavity wall ties will be created between two walls.
cavity (as float): Cavity distance only when one wall has been given as input. This is the dimension between the inner- and outer leaf of cavity wall, in [m].
outer wall thickness (as float) in [m], only when one wall has been given as input and may be omitted if wall thickness is same as inner leaf.
outer_wall_material (as string): Material for the outer wall, only when one wall has been given as input and may be omitted if wall material is same as inner leaf. Alternative (str): Name of the material. If the material does not yet exist it will be created.
flip (as bool): Not obligatory, default value is ‘False’. If flip is true, the new leaf will be placed on the inner side of the existing wall.
edge_distance (as float): Distance between cavity wall ties and the edges of the wall.
wall_tie_distance (as float): Mutual distance between cavity wall ties.

Output:

The strengthening measure is added to class of springs and modelled in DIANA or SCIA.

viia_l4f(variant: int, wall: Union[Wall, str], offset_bottom: float = 0.1, offset_top: float = 0.1, flip: bool = False)

This function creates an L4-F-measure for a selected wall. It adds vertical wooden beams (including eccentricity) It will model the column if it is of certain length and not in openings. The wall should be vertical, but angled in horizontal plane is okay. Also the top and bottom do not have to be straight.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
wall (obj): The object reference of the wall that has to be strengthened. Alternative (str): Name of the wall to be strengthened.
offset_bottom (float): Not obligatory, default value is 0.1m. This is the offset of the steel beam to the bottom edge of the wall opening in [m].
offset_top (float): Not obligatory, default value is 0.1m. This is the offset of the steel beam to the top edge of the wall opening in [m].
flip (bool): Default value is False, indicating that the columns created have an eccentricity applied in the direction of the local z-axis of the wall. If set to True, the eccentricity will be applied in the opposite direction.

Output:

The strengthening measure is added to class of columns and modelled in DIANA or SCIA.

viia_l4i(variant: int, wall: Union[Wall, str], explicit: bool = False)

This function creates an L4-I-measure for a selected wall. It replaces a masonry wall with a timber frame wall (HSB). It will model the wall the same as the existing wall and thus not in openings. The wall should be vertical, but angled in horizontal plane is okay. Also the top and bottom do not have to be straight.

Warning

Function is currently not available, it requires updates, please send request to the VIIA automating team.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
wall (obj): The object reference of the wall that has to be strengthened. Alternative (str): Name of the wall to be strengthened.
explicit (bool): Not obligatory, default value is ‘False’. In that case an equivalent wall is modelled. If

‘True’, the vertical wooden beams and multiplex sheets are modelled explicitly

Output:

The strengthening measure is executed and the new wall is modelled in DIANA or SCIA.

For example:

>>> project.viia_l4i(wall)

This example will apply the L4-I measure, which replaces masonry wall Wall5 with an equivalent timber frame wall.

viia_l4o(variant: int, wall: Union[Wall, str], offset_bottom: float = 0.1, offset_top: float = 0.1, strip_profile: str = '20x1.4')

This function creates an L4-O-measure (Quakeshield) for a selected wall. It adds the vertical CFRP-strips. It will model the beam if it is of certain length and not in openings.The wall should be vertical, but angled in horizontal plane is okay. Also, the top and bottom do not have to be straight.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC. From ‘1’ to ‘4’, for 1.0m, 0.75m, 0.5m and 1.25m respectively.
wall (obj): The object reference of the wall that has to be strengthened. Alternative (str): Name of the wall to be strengthened.
offset_bottom (float): Not obligatory, default value is 0.1m. This is the offset of the wooden beam to the bottom edge of the wall in [m].
offset_top (float): Not obligatory, default value is 0.1m. This is the offset of the wooden beam to the bottom edge of the wall in [m].
strip_profile (str): Specifies the profile of the CFRP strips. Not obligatory, all measure variants on the GMC have a standard of ‘20x1.4’. The alternatives are ‘30x1.4’ and ‘30x2.5’.

Output:

The strengthening measure is added to class of columns and modelled in DIANA or SCIA.

For example:

>>> project.viia_l4o(wall, variant=1)

This example will apply the L4O measure with 20mm x 1.4mm CFRP strips spaced 1m .

>>> project.viia_l4o(wall, variant=4, strip_profile='30x2.5')

This example will apply the L4O measure with 30mm x 2.5mm CFRP strips spaced 1.25m .

viia_l4r(variant: int, wall: Union[Wall, str], offset_left: float = 0.2, offset_right: float = 0.2)

This function creates an L4-R-measure for a selected wall. It adds vertical steel columns with horizontal wooden beams (generally 100x200, 400 ctc), including eccentricity. It will model the columns and beams around wall openings with the offset specified in the project. The wall should be vertical, but angled in horizontal plane is okay. Also the top and bottom do not have to be straight. offsetLeft and offsetRight define the offsets of the first and last column from the edge of the wall.

Warning

Function is currently not available, it requires updates, please send request to the VIIA automating team.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
wall (obj): The object reference of the wall that has to be strengthened. Alternative (str): Name of the wall to be strengthened.
offset_left (float): Not obligatory, default value is 0.2m. This is the offset of the first steel column to the left edge of the wall in [m].
offset_right (float): Not obligatory, default value is 0.2m. This is the offset of the last steel column to the right edge of the wall in [m].

Output:

The strengthening measure is added to class of columns and beams and modelled in DIANA or SCIA.

For example:

>>> project.viia_l4r(wall, 0.3, 0.2)

This example will apply the L4-R measure with vertical steel columns and horizontal wooden beams, for out-of-plane strengthening, to teh wall with an offset at the left of 0.3m and 0.2m at the right.

viia_l5a(variant: int, wall: Union[Wall, str], application_type: str = 'center') → Tuple[Wall, MainSurfaceReinforcement]

This function creates a L5-A-measure (Reinforced concrete wall addition) for a selected wall. It adds a concrete wall of 60mm, C20/25 (shotcrete) and applies a grid reinforcement of 1x2R8*-150. *2R12 IS ADDED. Optional is the inclusion of eccentricity.

The strengthening measure will be modelled around openings and can be applied on walls in all directions.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
wall (obj): The object reference of the wall that has to be strengthened. Alternative (str): Name of the wall to be strengthened.
application_type (str): Default value is ‘center’, in which case no eccentricity is applied. If ‘outward’ or ‘inward’ is provided the eccentricity direction is determined based on the connected floors. If ‘positive’ or ‘negative’ is provided the eccentricity direction is determined based on the normal vector of the wall. Accepted input options are ‘center’, ‘outward’, ‘positive’, ‘inward’ or ‘negative’.

Output:

The strengthening measure is added to the wall as sub-shapes.
Newly created wall shape and reinforcement shape are returned in a tuple; first is wall and second is the surface reinforcement.
The strengthening measure is created in DIANA (if software is DIANA and model created).

For example:

project.viia_l5a(wall)
This example will apply the L5-A measure with a concrete wall and grid reinforcement. No eccentricities applied.
project.viia_l5a(wall, 'positive')
The example has the same result as the previous, but now eccentricity in the direction of the local Z-axis of wall has been applied.

viia_l5b(wall: Union[Wall, str], application_type: str = 'Center', variant: int = 1)

This function creates an L5B-measure, i.e. replacing a selected wall with a reinforced concrete wall. It adjusts the properties of the original wall with a wall of 200mm, C20/25 and applies two sheets of grid reinforcement of R12_150 in both directions. Inclusion of eccentricity is optional, for which one sheet is applied at both edges of the wall. It will model the strengthening measure around openings and can be applied on walls in all directions.

Warning

Function is currently not available, it requires updates, please send request to the VIIA automating team.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
wall (obj): The object reference of the wall that has to be strengthened. Alternative (str): Name of the wall to be strengthened.
application_type (str): Default value is ‘Center’. In that case no eccentricity is applied. If ‘Eccentric’ the grid reinforcement will be applied with corresponding eccentricity (set in constants for VIIA).
variant (int): The variant number of the measure that is in the GMC.

Output:

The strengthening measure is added to the wall and modelled in DIANA or SCIA.

For example:

>>> project.viia_l5b(wall)

This example will apply the L5B measure and adjust the wall in the model to a concrete wall of 200mm with a grid reinforcement 2x2R12-150.

>>> project.viia_l5b(wall, application_type='Eccentric')

The example has the same result as the previous, but the grid reinforcement has been applied with eccentricity (both sides of the wall).

viia_l5n(wall: Union[Wall, str], application: str = 'Center', variant: int = 1)

This function creates an L5N-measure (Reinforced concrete wall addition) for a selected wall. It adds a concrete wall of 150mm, C20/25 and applies a grid reinforcement of 2x2R12-150. Optional is the inclusion of eccentricity.

It will model the strengthening measure around openings and can be applied on walls in all directions.

Warning

Function is currently not available, it requires updates, please send request to the VIIA automating team.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
wall (obj): The object reference of the wall that has to be strengthened. Alternative (str): Name of the wall to be strengthened.
application (str): Default value is ‘Center’. In that case no eccentricity is applied. If ‘Positive’ or ‘Negative’ the measure will be applied with corresponding eccentricity. Positive is in the direction of the local z-axis of the strengthened wall. Input ‘Center’, ‘Positive’ or ‘Negative’.
variant (int): The variant number of the measure that is in the GMC.

Output:

The strengthening measure is added to the wall and modelled in DIANA or SCIA.

For example:

project.viia_l5n(wall=wall)

This example will apply the L5-N measure with a concrete wall and grid reinforcement. No eccentricities applied.

project.viia_l5n(wall=wall, application='Positive')

The example has the same result as the previous, but an eccentricity has been applied in the direction of the local z-axis of the wall.

viia_l5p(variant: int, wall: Wall, application_type: str = 'both', eccentricity: bool = True) → List[Union[Wall, MainSurfaceReinforcement]]

This function creates an L5-P-measure (Quakeshield mesh with shotcrete) for a selected wall. It adds a concrete wall of 20mm on both sides of the wall, C35/45 and applies a grid reinforcement of Quakeshield. Optional is to apply the measure only on one side and the inclusion of eccentricity.

Note

When applying on one side, eccentricity is always taken into account.

Warning

The tyings are not modelled, these need to be added manually.

It will model the strengthening measure around openings and can be applied on walls in all directions.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
wall (obj): Object reference of the wall that has to be strengthened.
application_type (str): Select the side to apply the measure on. Default value is ‘both’, applying the measure on both sides of the wall. If ‘positive’ or ‘negative’ is provided as argument, the measure will be applied on that side of the wall only. Positive is in the direction of the local z-axis of the strengthened wall.
eccentricity (bool): The eccentricity of the strengthening is applied by default when applying the measure on both sides. Default value is True. This input is ignored when application-type is ‘positive’ or ‘negative’, eccentricity is always applied in these cases.

Output:

The strengthening measure is added to the wall. Newly created walls and reinforcements are returned in a list.

viia_l6j(variant: int, add_slab: bool = False)

This function creates an L6-J-measure which adds a concrete slab to the existing foundation strips of the building. It thereby prevents uncontrolled displacement due to loss of load bearing capacity. Existing foundation strips are effectively merged into one slab, openings in the slabs are removed.

Warning

Function is currently not available, it requires updates, please send request to the VIIA automating team.

Note

This function is based on an algorithm in which the foundation strips are ordered according to their coordinates, after which the strips are connected by searching for points of consecutive strips that are closest to each other. The algorithm seems to work well, but it is very hard to capture all possibilities of defined foundation strips. It is therefore possible that errors occur or that the outcome of the function is not the desired foundation slab.

Note

For a merged foundation strip (add_slab=False) the geometry and material are equal to that of the first foundation strip in the list.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
variant (int): The variant number of the measure that is in the GMC.
add_slab (bool): Default value is False. If addSlab is True, a slab is added just above the foundation strips with reinforcement Ø12-150, effectively connecting all foundation walls to prevent uncontrolled deformations. If False, the existing foundation strips are merged into one strip without openings.

Output:

Foundation strips are merged into one slab and modelled in DIANA, or
Slab is added just above the foundation strips and modelled in DIANA

For example: >>> project.viia_l6j()

This example will apply the L6-J measure on the building, merging all foundation strips into one strip.

>>> project.viia_l6j(add_slab=True)

This example will apply the L6-J measure on the building, a new slab is created based one the definition of the foundation strips. The slab will be positioned just above the existing strips.

viia_linear_properties(shapes: List[Union[str, Shapes, Connections]] = None)

This function removes all non-linear materials and replaces them for the linear version of it. It does not affect the soil, the soil-structure interaction (SSI) interface and the piles (which can be set linear separately). Function can operate before and after creating model in DIANA.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
shapes (list with obj): List with shape and/or connection object references, of which the properties must be adjusted. If ‘None’, all non-linear materials will be replaced, except for the above-mentioned materials. Alternative (list with str): List with shape and/or connection names, of which the properties must be adjusted.

Output:

All non-linear materials of shape objects that are given, are replaced with the linear version.
If model is created the materials will be updated in DIANA.
A list is saved with references to original non-linear material that was assigned, this list can be found in project.project_specific[‘lists’][‘nonlinear shapes original’].
The object of the non-linear material is not removed when it is not used anymore. In DIANA the materials are removed when they are not used anymore (if model has been created).

viia_make_picture_strengthening_measures(name: str, picture_type: str = 'Model')

Function to create a picture of the specified view for strengthening measures. The picture ‘BUILDING’ of model pictures is created by default. If this is not present a (random) picture from the model picture dictionary is selected to be created.

Input:

project (obj): Project object containing collections and of fem objects and project variables.
view_name (str): Name of the view of which a picture is created.
picture_type (str): Type of picture to be created. Can be ‘Model’ or ‘Result’. Default value ‘Model’.

Output:

Picture is created from view.

viia_materials(material_name: str, hbv_span: Optional[float] = None, hbv_width: Optional[float] = None)

This function will collect the arguments for the creation of an object based on the name of the element material. The VIIA naming convention is applied in this function and sub-functions it uses.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
material_name(str): Name of the element geometry.
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:

Returns the object reference to the ‘Material’ object that is created based on the input arguments.

viia_model_pictures(backside: bool = False, odb_file: str = None, software: str = 'diana', add_legend: bool = True, legend_loc: str = 'upper right', legend_fontsize: int = 7)

This function creates the model pictures. It will place them in the default model picture folder (viiaStatus). If DIANA is used, this function will only be performed if running in DIANA and when model is created and the results are loaded.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
backside (bool): If set to True, also the pictures in the opposite direction are created.
odb_file (str): Name of odb_file used to make model pictures in Abaqus.
software (str): Software that is used to create the model pictures. Options are ‘diana’ and ‘abaqus’. Default value is ‘diana’.
add_legend (bool): Indicates if a legend should be added to the pictures.
legend_loc (str): The legend location which is used for matplotlib. Default location is upper right.
fontsize (int): The font size of the legend used for matplotlib. Default value 7.

Output:

The default views are generated.
The pictures are generated in the model picture folder with the current time stamp and version.

viia_modify_analysis(mod_param: List[List[str]], analysis: Analysis, run: bool = False, combox: str = 'Server', create_files: bool = True, save_mode_pictures: Optional[int] = None)

This function will modify the analysis object, create analysis object in DIANA and save model and Analysis files (dat, dpf and dcf-files) in the analysis sub-folder.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
mod_param (list(list)): parameters containing arguments for modifying the analysis object
analysis (obj): Object reference of ‘Analysis’ class. only work with Analysis object of A10 and A12 analysis.
run_analysis (bool): Bool to define whether to run analysis or not. ‘False’ by default.
combox (str): string that define whether analysis will be run. set to ‘Server’ by default.
create_files (bool): Bool to define if dcf, json, dat, and dpf files should be created. By default, set to True. If set to False, then new files will not be created.
save_mode_pictures (int): This refers to number of modes, for which the result items displacement DispXYZ and rotation RotXYZ is plotted for the entire structure. Useful for A3/A7 analysis. Default in this situation is set to None.

Output:

The analysis object is modified, is returned and all the relevant files are created in the project workfolder.

Examples:

analysis_A10 = project.viia_analysis(analysis_nr='A10', run=False, suppress_analysis=True)

project.viia_modify_analysis(analysis=analysis_A10, mod_param=[
    ['Structural nonlinear 4', 'Execute block E', 'equilibrium iteration','maximum number of iterations',
     100], ['Structural nonlinear 6', 'OUTPUT_STATIC-NL', 'user selection','nodes', [28,173,990,1783]]])

viia_move_cavity_wall_tie(cavity_wall_tie: Spring, new_coordinates: List[float]) → Spring

Function to move a cavity wall tie object to a new specified coordinate on the inner leaf. A vector is constructed from the old coordinates of the node on the source connecting shape to the new coordinates. The node on the target connecting shape is moved along this same vector.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
cavity_wall_tie (obj): Object reference to the cavity wall tie that needs to be moved.
new_coordinates (list of 3 floats): New coordinates of the wall tie object. The new position should be provided on the inner leaf.

Output:

Spring object and two internal points on the walls to which it connects are moved accordingly. The updated spring object is also returned.

viia_movie_maker()

This function will create a movie from the movie pictures that have been created in the picture script.

Input:

project (obj): Project object containing collections and of fem objects and project variables.

Output:

A movie in mpeg format is created.

viia_nlka_graph_data(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.

viia_nlka_tool(): This function is developed for the NLKA assessment that is part of the VIIA project workflow. The assessment is performed in a seperate tool for which a graphical interface is provided. The tool should run in a python-editor (like PyCharm) and can’t be used in DIANA.

Note

The function requires the FPDF 3rd party module.

viia_node_data_diana(view_nodes: List[Union[Node, List[float]]]) → List[Path]

This function creates pdf documents containing the DIANA node/element and connection data at the location of nodes specified by the user.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
view_nodes (list of node objects or node coordinates): A list that can contain either objects of the class Node or a sublist containing 3 floats representing the node coordinates in [m] e.g. [1.20, 5.00, 3.50]. For each node a pdf document is created.

Output:

A folder called “Node Data” is created in the working folder which contains the pdfs (each pdf corresponding to each node), which contains the node/element data and connection data.
Returns list of all generated pdf-files.

viia_non_linear_properties()

This function replaces all linear materials created with viia_linear_properties with the original material. Function only works if viia_linear_properties has been executed.

Note

The function viia_linear_properties must have been executed previously.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

All shapes and connections with originally non-linear materials are reset.

viia_openings_on_contour_wall(wall: Union[Wall, str], margin: float = 0.005)

In Dutch: ‘Kantelen wanden’. This function analyses a wall object for incorrectly defined openings which are part of the main element. The element is adapted such that an opening will be added to the element. These incorrectly defined openings are caused by the revit export having openings on the boundary of an element.

This script will add by default a 5 mm margin between the element boundary and the generated opening to prevent errors with openings laying outside of the element itself.

..warning:: this script will not work correctly if the wall geometry is non-rectangular: (for example if the wall has a slanted side).

..note:: this functions applies a projection to 2D and back. very small rounding errors might be introduced.

..note:: in previous versions nodal rounding to 1 mm was applied, this is now removed.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
wall (obj): Object refeence of the wall that needs to be checked and adapted for incorrect openings. Alternativa (str): Name of the wall. The wall must be available in the PY-memory.
margin (float): The margin in [m] between the element boundary and the generated opening to prevent errors with openings laying outside the element itself.

Output:

The wall passed to this function will have the geometry adapted with a new element geometry and added openings that have been found that were incorrectly part of the main element.

viia_phased_analysis()

Function to prepare for phased analysis, based on layers following VIIA name convention. Returns list with shapes, connections, supportsets and tyings active per phase.

Warning

Function makes use of shapes and connections in the dictionaries in Collections. Make sure all elements are present in those dictionaries.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

A list is generated and returned, containing the elements that are active in different phases list per phase consists of 4 lists of elements: shapes, connections (except for tyings), supports and tyings.

viia_pile_tool()

This function is developed for the pile calculation that is part of the VIIA project workflow. The assessment is performed in a separate tool for which a graphical interface is provided. The tool should run in a python-editor (like PyCharm) and can’t be used in DIANA.

The function requires the PyQt5 3rd party modules.

viia_plot_foundation_details(save_folder: Optional[Path] = None, dpi: Optional[int] = None) → List[Path]

This function plots the unique foundation details for shallow foundations in the model. This includes strip and stepped foundations that have been created with the functionality in the viiaPackage. The functionality expects a grid to be defined.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
save_folder (str): Path to folder where the pictures should be saved. Default value is None, in which case the current workfolder will be used.
dpi (int): Optional input to specify the quality of the picture (use for bigger plots). Default value is None, using default matplotlib dpi setting.

Output:

Returns a list of files with the plots of the foundation details.
The first file presents an overview of the locations of the foundation details in the model.

viia_plot_grid(plot_levels: bool = True, levels_plotting_plane: Optional[str] = None, show: bool = False, save_folder: Optional[Path] = None)

This function plots all grids in the collections of the project. Optionally the levels defined in the grids are plotted. The plotting methods for the fem package are used to create the plots.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
plot_levels (bool): Optional boolean to choose whether the levels are plotted. Default is True.
levels_plotting_plane (str): Optional string (choose ‘xz’ or ‘yz’) to set the plotting plane for the levels.
show (bool): Optional boolean to choose whether to show the plots. Default value is False, not showing.
save_folder (Path): Path location to save the plots. If no path is specified, the current workfolder is used.

Output:

Plot of all the grids in the project is saved to the requested folder.
Optional plot of the levels is saved to the requested folder.

viia_plot_layers(layers: Optional[Union[List[str], List[Layer], str]] = None, view: str = '2D', shape_types: Optional[Union[str, List[str]]] = None, grid: Optional[Union[Grid, int, str]] = None, shape_types_together: Optional[bool] = None, thickness_scale: float = 1, show: bool = True, show_dimensions: bool = True, save_folder: Optional[Path] = None, file_name: Optional[str] = None)

This function plots either all or the specified layers and all or the specified shape types.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
layers (list of obj): List of layer objects to plot. Default value is None, in which case all the layers are plotted. Alternative 1 (list of obj): List of strings representing the layers to plot. Alternative 2 (str): String representing one layer to plot.
view (str): Optional string to indicate whether layer(s) should be plotted in 2D or 3D. Default value is ‘2D’.
shape_types (str): String indicating the shape type to plot. Default value is None, in which case all walls, floors, roofs, beams and columns are plotted
grid (Grid, int, str): Optional object, id or name of the grid to use. By default, the first grid in the collection is used.
shape_types_together (bool): If True, all shape_types defined are plotted together in the same plot. If False, a plot is generated separately for each shape type.
thickness_scale (float): A scaling factor for the thickness of the plotted walls. Default value is 2.
show (bool): True if plots will be shown, otherwise they are just saved in the given folder. Default value is True.
show_dimensions (bool): True if dimensions should be plotted. Default value is True.
save_folder (Path): Path to folder to save plots in. If not provided, plots are saved in sub folder ‘Modelling Pictures’ in working folder.
file_name (str): Name of the file to save the plot as. If not provided a name will be generated based on layer name and shape-types.

Output:

All specified or default layers and shapes are plotted and shown if desired.
All plots made are saved in the specified or default folder.

viia_plot_psse_nsce(settings: PSSENSCEPlotSettings = PSSENSCEPlotSettings(psse_color='#C00040', nsce_color='#4040C0', psse_linewidth=3, nsce_linewidth=3, figsize=(10, 10), subfolder='PSSE NSCE', file_base_name='Element Classification'), show: bool = False, grid: Optional[Grid] = None) → List[Path]

Function to create the psse and nsce plots. By default, psse’s are plotted in red and nsce’s in blue. All shapes that have either structural type PSSE or NSCE defined in their metadata are included in the plots. A separate image is created for each layer.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
settings (obj): Settings object for the plot, including styling and save location.
show (bool): Toggle to show the plot. Default is False.
grid (Grid): Optional grid object to plot behind the shapes. Default is the first grid in the collections.

Output:

Plots are created in the specified folder. Default location is workfolder/Appendix Pictures/PSSE NSCE.

viia_prepare_for_engineering_report(governing_analysis: str, folder_a7: Optional[Path] = None, folder_a10: Optional[Path] = None, folders_a12: Optional[Dict[str, Path]] = None, folder_a13: Optional[Path] = None, folders_a15: Optional[Dict[str, Path]] = None) → Dict[str, Path]

This function collects the folders with analyses relevant for the reporting in TVA of the NLTH. It provides options for the user to check the inputs and overrule if needed. It will load the model of the governing analysis, which is used for the automated reporting (mesh data, applied strengthening measures, etc.).

Note

This function should be run in the report script, there should not be a model loaded prior to this function. Checks are performed if all required data is found and correct. Please follow VIIA workflow.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
governing_analysis (str): Governing analysis for NLTH results. For NLTH report the governing analysis can be selected from ‘S1’, ‘S2’, ‘S3’, ‘S4’, ‘S5’, ‘S6’, ‘S7’, ‘S8’, ‘S9’, ‘S10’ or ‘S11’.
folder_a7 (Path): Path of the A7 analysis folder where the results of the analysis can be found. Default value is None, in which case the folder is automatically retrieved based on naming conventions in VIIA.
folder_a10 (Path): Path of the A10 analysis folder where the results of the analysis can be found. Default value is None, in which case the folder is automatically retrieved based on naming conventions in VIIA.
folders_a12 (dict): Dictionary with the paths of the A12 analysis to be used. Default value is None, in which case the folder is automatically retrieved based on naming conventions in VIIA.
folder_a13 (Path): Path of the A13 analysis folder where the results of the analysis can be found. Default value is None, in which case the folder is automatically retrieved based on naming conventions in VIIA. Only used for objects with strengthening.
folders_a15 (dict): Dictionary with the paths of the A15 analysis to be used. Default value is None, in which case the folder is automatically retrieved based on naming conventions in VIIA. Only required for strengthened objects.

Output:

Returns dictionary with the folders with the results to be used in the report. Notifications are printed to inform the user which folders are used.

viia_print_execution_time()

Function prints and logs the execution time of the MainScript (to the point where the functions is set).

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Prints the execution time and logs it.

viia_projection_on_surface(point: List[Union[float, Shapes, str]])

Function that calculates the unknown coordinate of a point by projection on a 2-dimensional shape.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
point (list with 3 floats or 2 floats and 1 shape): If 3 floats are given, the output is the unmodified point. If 2 floats and 1 shape is given, the unknown coordinate at the index of the shape is calculated by projection on this shape. Shapes can be inputted as objects or strings e.g. [19.2, roof_1, 6] OR [19.2, ‘roof_1’, 6].

Output:

Returns the coordinates of the projected point.

viia_read_dump(filename='Dump', remove_collections=True, loading_model: str = 'all', *args)

Function can be used to reload a model created earlier.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
filename (Path or str): Name of the file to be read. It is not required to add the suffix (json), but the file must have the json extension.
remove_collections (bool): Before adding new elements to the model, the existing ones are removed by default. Default value is True.
loading_model (str): Defines the categories to be loaded, different sets are created, increasing the amount of elements to be loaded. Default value is ‘all’, collecting all data from the json-file.
args (str): Any sub-folders relative to the working folder can be added.

Output:

The json is read and objects in it are initialised.

viia_read_myviia_model(analysis: str = 'A1') → Dict[str, Any]

This function will collect the model from MYVIIA that was uploaded for a specified analysis. The function will raise an error when there is already a model present, or if something went wrong in the process to collect or read.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
analysis (str): Name of the analysis for which the model should be loaded, for example ‘A1’.

Output:

The model is read from MYVIIA and loaded into project.
Returns model summary of the loaded json.

viia_ref_table(ref_element: Union[RefWallIP, RefWallOOP], output_folder: Optional[Union[Path, str]] = None) → Path

This function collects all referenced object models and creates an Excel sheet with a (sorted) list of all walls in the referenced object models. This list is compared to the wall currently being investigated.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
current_element (dict): CurrentWall object, containing information about the element currently investigated.
ref_element (dict): RefWallIP or RefWallOOP object, containing information about chosen referenced element.
output_folder (Path): Optional input for location where to create the Word file. Default value is None, indicating the default location is used. In normal production objects do not change this!

Output:

Returns a Word file with a filled in table for the assessment of an element in the Reference Approach.

viia_remove_cavity_wall_tie(tie: Spring)

This function removes a cavity wall tie from the project. The corresponding internal points on the inner and outer leaf will also be removed. If these nodes are not used by other shapes, they will also be removed.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
tie (obj): Object reference to the spring describing the wall tie.

Output:

Returns the spring object will be deleted from the project. The shape geometries to which it connects will also be removed if they are not used by other shapes.

viia_remove_load_combination(load_combination_name: str)

This function removes the requested load-combination. In case of Earthquake or Base Motion it is not necessary to remove x, y and z separately. The input should be then ‘Earthquake’ or ‘Base Motion’.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
load_combination_name (str): Name of the load-combination that needs to be removed. All names of load-combinations in project.collections.load-combinations are valid. When removing ‘Earthquake’ or ‘Base Motion’, it is not necessary to remove those separately per direction.

Output:

Geometry load-combination is removed in DIANA (if software is DIANA and model created).
If model also meshed, the mesh load-combination is removed in DIANA (if software is DIANA and model created).
‘LoadCombination’ object is removed.
In case of a base motion or earthquake load-combination, the current signal is set to None.

viia_remove_load_combination_base_motion()

This function removes the load-combinations for the seismic base motion situation.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load-combinations for 3 base motions (x, y, and z) are removed.
The status variable ‘CurrentSignal’ in ‘Project’ is set to None.

viia_remove_load_combination_earthquake()

This function removes the load-combination for the earthquake situation.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load-combinations for 3 earthquake directions (x, y, and z) are removed.
The status variable ‘CurrentSignal’ in ‘Project’ is set to None.

viia_remove_load_combination_push_over()

This function removes the load-combinations for the pushover situation, including the Redis pushover.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load-combination is removed.

viia_remove_load_combination_response_spectrum()

This function removes the load-combinations for the MRS analysis.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load-combinations are removed.

viia_remove_load_combination_rob_test()

This function removes the load-combination for the Rob-test situation.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load combination is removed.

viia_remove_loadcombination(load_combination_name: str)

This function removes the requested load-combination. In case of Earthquake or Base Motion it is not necessary to remove x, y and z separately. The input should be then ‘Earthquake’ or ‘Base Motion’.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
load_combination_name (str): Name of the load-combination that needs to be removed. All names of load-combinations in project.collections.load-combinations are valid. When removing ‘Earthquake’ or ‘Base Motion’, it is not necessary to remove those separately per direction.

Output:

Geometry load-combination is removed in DIANA (if software is DIANA and model created).
If model also meshed, the mesh load-combination is removed in DIANA (if software is DIANA and model created).
‘LoadCombination’ object is removed.
In case of a base motion or earthquake load-combination, the current signal is set to None.

viia_remove_loadcombination_base_motion()

This function removes the load-combinations for the seismic base motion situation.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load-combinations for 3 base motions (x, y, and z) are removed.
The status variable ‘CurrentSignal’ in ‘Project’ is set to None.

viia_remove_loadcombination_earthquake()

This function removes the load-combination for the earthquake situation.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load-combinations for 3 earthquake directions (x, y, and z) are removed.
The status variable ‘CurrentSignal’ in ‘Project’ is set to None.

viia_remove_loadcombination_push_over()

This function removes the load-combinations for the pushover situation, including the Redis pushover.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load-combination is removed.

viia_remove_loadcombination_responsespectrum()

This function removes the load-combinations for the MRS analysis.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load-combinations are removed.

viia_remove_loadcombination_rob_test()

This function removes the load-combination for the Rob-test situation.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Load combination is removed.

viia_remove_loads(load_type: str)

This function removes a given predefined load, coupled to the requested load-types.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
load_type (str): name of the load that needs to be removed, available are: “Self weight”, “Imposed load”, “Rob Tests”, “Base Motion”, ‘Push_over_equivalent_acc’, ‘Push_over_modal’ and ‘Push_over_uniform’. Other options are also possible such as: ‘force’, ‘moment’, ‘projected-force’, ‘translation’, ‘rotation’, ‘hydrostatic’, ‘thermal’, ‘rotational-acceleration’, ‘self-weight’, ‘acceleration’, ‘centrifugal-force’, ‘base-excitation’.

Output:

Geometry load is removed from the model and in DIANA.

viia_remove_shape(shape: Union[str, Shapes])

Function to remove a shape from project in the VIIA project. In VIIA certain data is saved to the meta-data. These object references should be removed as well at the moment the referenced shape is removed. Normal FEM procedure to remove the shape is performed afterward.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
shape (obj): Object reference of the shape to be removed. Alternative input can be the name or ID of the shape.

Output:

Any reference in the meta-data for VIIA is removed.
The object is deleted in DIANA (if software is DIANA, model created and not a sub-shape).
Before deleting from PY-memory all collections are checked and updated.
The object is deleted in PY-memory.

viia_remove_supports()

This function removes all shallow foundation supports that were previously modelled.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

All supports for shallow foundtions are removed.

viia_remove_temporarily_pile_supports_for_rob_test()

This function removes the temporarily added vertical restraints on the bottom node of the piles to perform the rob-test. It counters the viia_update_pile_supports_for_rob_test function.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

The pointsupports for piles in the rob-test constraining the vertical degree of freedom are removed. This is done based on the name of the support, if it contains the text ‘-temp_for_robtest’.

viia_restructure_folder(analysis_nr: str)

This function restructures an A4, A12 or A15 folder from the old structure to the current structure. The current structure involves a folder whose name contains the timestamp. This timestamp folder contains folder(s) corresponding to signal(s).

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
analysis_nr (int): The analysis number as a string. The acceptable analysis_nr are ‘A4’, ‘A12, ‘A15’.

Output:

The function does not return anything. A new folder is created with the new folder structure. The old folder remains with ‘ old’ added in front of its name, however, its contents are moved to the new folder.

viia_results(analysis_nr: str, out_file: Optional[Union[Path, str]] = None, dat_file: Optional[Union[Path, str]] = None, signal: Optional[str] = None, runtime: Optional[float] = None, geo_output: Optional[bool] = True, node_foundation: int = None, node_top: int = None, bsc_nls_dir: Optional[Path] = None, tva_nls_dir: Optional[Path] = None, save_mode_pictures: Optional[int] = 5, load_model: bool = True, json_file: Optional[Union[Path, str]] = None, convergence_graphs: bool = True, base_shear_graphs: bool = True, wall_displacement_graphs: bool = True, acceleration_graphs: bool = True, result_pictures: bool = True, diana_view_point: Optional[Union[Tuple, List]] = None)

This function will perform the result handling for the selected analysis. It will retrieve the DIANA calculation files from the requested or the most recent analysis folder if not specified. What result pictures / graphs or other info is retrieved is different for the analysis.

Note

Most analysis result handling require this function to be run in DIANA to generate the requested result pictures.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
analysis_nr (str): Number of the VIIA analysis. For example ‘A1’.
out_file (path): The DIANA out-file location and filename of the analysis requested as path. Optional input, if not provided the out-file will be retrieved from the analysis folder. Alternative (str): The DIANA out-file location and filename of the analysis requested as string.
dat_file (path): The ABAQUS dat-file location and filename of the analysis requested as path. Optional input, if not provided the dat-file will be retrieved from the analysis folder. Alternative (str): The ABAQUS dat-file location and filename of the analysis requested as string.
signal (str): The signal for which the results need to be created. Example format is ‘S1’. This is used for A4, A12 and A15 analysis. Default value is None.
runtime (float): The time that the analysis ran, in [s]. This value is optional and only used to log and stored in database. Default value is None.
geo_output (bool): This allows the user to choose if the geo output needs to be created. This can be handy if the user wants to create results for multiple signals together. Then the user does not need to create the geo output each time. Currently used only for analysis A12. Default value is set to True.
node_foundation (int): Optional node number from which to extract the foundation accelerations. If no input is given, the first node encountered in both a fstrip and the tb-file is used
node_top (int): Node number from which to extract the top of building accelerations. If no input is given, the node from the tb-file with the highest z-coordinate is selected.
bsc_nls_dir (Path): The path for BSC A10 folder. If there is no difference in the mass and load distribution between BSC and TVA, the geo output will be the same for BSC and TVA.
tva_nls_dir (Path): The path for TVA A13 folder, default is None. If None, the geo output will be the same for BSC and TVA. Otherwise, the TVA A13 folder should be specified.
save_mode_pictures (int): This refers to number of modes, for which the result items displacement DispXYZ and rotation RotXYZ is plotted for the entire structure. Default value is set to 5.
load_model (bool): Select to reload the model. Default value is True, but when directly creating analysis and running, it needs to be switched off.
json_file (path): The json-file of the model, location and filename of the analysis requested as path. Alternative (str): The json-file location and filename of the analysis requested as string. Default value is None, using the default VIIA path for analysis files.
convergence_graphs (bool): Toggle to generate convergence graphs in NLTH analyses. Default value is True.
base_shear_graphs (bool): Toggle to generate base shear graphs in NLTH analyses. Default value is True.
wall_displacement_graphs (bool): Toggle to generate wall displacement graphs in NLTH analyses. Default value is True.
acceleration_graphs (bool): Toggle to generate acceleration graphs in NLTH analyses. Default value is True.
result_pictures (bool): Toggle to generate result pictures in NLTH analyses. Default value is True.
diana_view_point (list or tuple): The diana view point that should be used for the picture. Can be used when the default view is not sufficient. (Use ‘currentViewPoint()’ in DianaIE to retrieve the diana view point). The diana view point is a list or tuple of 11 floats where: 1st to 3rd values are camera position coordinates, 4th to 6th values are camera view vector direction, 7th to 9th values are camera focal point coordinates, 10th value is camera viewing angle in degrees and 11th value is the viewpoint height. When None the default view will be used. Default is None.

Output:

The required result pictures are generated. For this the function should run in DIANA.
The required graphs are created.
The required data is retrieved from the files and returned.
All files are generated in the analysis folder.

viia_scoring_current_wall(current_wall: Dict[str, Union[str, float]], ref_walls_data: List[Dict], ref_walls: Union[List[RefWallIP], List[RefWallOOP]], ref_models: Dict = None, output_folder: Optional[Union[Path, str]] = None, save_xls: bool = True) → Union[Path, List[Dict]]

This function compares the data of currently investigated walls and data of all walls from all referenced objects, and gives scores for each item in comparison.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

current_wall (dict): Data about the current wall. Example:

For in-plane walls:
current_wall = {
    'Object part': '313B - Woonhuis',  # str (Object and Object part)
    'Layer': 'N5',                     # str (VIIA layer, optional)
    'Material': 'MW-KLEI<1945',        # str (VIIA material)
    'Width': 4.05,                     # float, in [m].
    'Height': 2.50,                    # float, in [m].
    'Thickness': 210,                  # int, in [mm].
    'Wall type': 'Outer wall',         # str ('Inner wall' or 'Outer Wall')
    'z-coordinate top': 2.5}           # float, in [m].

For out-of-plane walls:
current_wall = {
    'Object part': '313B - Woonhuis',             # str (Object and Object part)
    'Layer': 'N5',                                # str (VIIA layer, optional)
    'Material': 'MW-KLEI<1945',                   # str (VIIA material)
    'Width': 4.05,                                # float, in [m].
    'Height': 2.50,                               # float, in [m].
    'Thickness': 210,                             # int, in [mm].
    'Wall type': 'Outer wall',                    # str ('Inner wall' or 'Outer Wall')
    'size_of_openings': [[1, 2], [1.0, 0.8]],     # list[list], in [m].
    'floor_spanning_direction': ['Parallel'],     # str ('Parallel' or 'Perpendicular').
    'roof_spanning_direction': ['Perpendicular'], # str ('Parallel' or 'Perpendicular').
    'overburden_load': 2                          # float, in [kN/m].

ref_walls_data (list): The list of dictionary with the data collected from all walls from all referenced objects.
ref_walls (list): The list of instance of all walls from all referenced objects.
output_folder (Path): Optional input for location where to create the report. Default value is None, indicating the default location is used. In normal production objects do not change this!
save_xls (bool): Indicates if the report should be saved as Excel or that the data dictionary should be returned .Default is True.

Output:

A list of dictionary with the scores for each wall from referenced objects compared to current wall.

viia_set_nsce(shapes: List[Shapes]) → None

This method sets the structural type of all passed in objects to NSCE. This is done by adding an entry to the meta_data of the shape.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
shapes (list of obj): List of shapes which will be set to NSCE.

Output:

Meta-data of shapes is added or updated.

viia_set_psse(shapes: List[Shapes]) → None

This function sets the structural-type of all passed in shapes to PSSE. This is done by adding an entry to the meta_data of the shape.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
shapes (list of obj): List of shapes which will be set to PSSE.

Output:

Meta-data of shapes is added or updated.

viia_shape_data_diana(view_shapes: List[Union[Shapes, str]] = None) → List[Path]

This function creates pdf documents containing the DIANA shape data of the shapes specified by the user.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
view_shapes (list of obj or str): A list of shape objects or shape names. For each shape a pdf document is created. If None all shapes will be used. Default is None.

Output:

A folder called “Mesh Check” is created in the working folder which contains the pdfs (each pdf corresponding to each shape), which contains the shape data.
Returns list of all generated pdf-files.

viia_show_picture(view_name: str, picture_type: str, picture_name: str, reinforcement: bool = True)

This function can be used to check a specific picture. It will show the picture on screen.

Input:

project (obj): Project object containing collections and of fem objects and project variables.
view_name (str): Name of the view to be presented on screen.
picture_type (str): Type of picture, can be ‘Model’ or ‘Results’.
picture_name (str): Name of the picture.
reinforcement (bool): Default value is ‘True’, reinforcements will be shown (if any exist in the picture).

Output

Picture is created on screen in DIANA.

viia_split_all_walls()

Function to make all openings storey height and replace the weight with line loads.

Warning

Line loads are not yet being applied. But a message is displayed which shows the size of the load.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

All the openings of the wall are made storey height. By doing this the wall is split and a new object is made for the second wall. If one of the walls has no openings nothing happens.

viia_split_surface(target: Union[Surfaces, str], tool: Union[Surfaces, Polyline, List[List[float]], str], keep: Optional[str] = 'largest')

Function to split (update the contour) a surface using the intersection with a tool object.

Input

target (obj): Object reference of ‘Surfaces’ that is the target of the splitting. Alt (str): Shapes can be inputted as a strings e.g. ‘roof_1’. Allowed shapes are floors, walls, roofs and fstrips. Also, the full name of the surface shape can be provided.
tool (obj): Object reference of ‘Surfaces’ containing the tool surface-shape used to split the other. Alt (obj): Object reference of ‘Polyline’ containing the contour of the tool surface. Alt (list of list of 3 float): List of points that represent the tool surface. Alt (str): Shapes can be inputted as a strings e.g. ‘floor_8’. Allowed shapes floors, walls, roofs and fstrips. Also, the full name of the surface shape can be provided.
keep (str): Indicate which surface(s) to keep. Options are ‘largest’, ‘smallest’, ‘top’, ‘bottom’. Default value is ‘largest’.

Output:

If splitting was performed correctly, the Surfaces object’s contour is updated.

viia_split_wall_horizontal(wall: Wall, splitting_height: Union[int, float], layer: Optional[str] = None, reference_point: Optional[List[float]] = None, precision: int = 9) → Wall

Function to split a wall horizontally based on a height (z-coordinate).

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
wall (obj): Object reference for Wall object that needs to be split.
splitting height (int, float): Height at which the wall will be split horizontally, the z-coordinate, in [m].
layer (str): Optional input if the newly created part of the original wall should be in another layer. For example when the original wall is in ‘N0’ you can specify ‘N1’ so the split part is added to layer N1. If not provided, the newly created wall is added to the same layer as the existing wall.
reference_point (list of 3 floats): Reference point that should be in the part of the wall that will be the original wall. The other part will be the new wall. If not specified, the new wall will be the upper part.

Output:

The wall is split in 2 parts, the original wall is adjusted and a new wall is created.
The new wall is generally the lowest of the 2 walls, except when the new wall belongs at a lower storey.
The new wall is returned.

viia_split_wall_vertical(point: List[float], direction: List[float] = None, reference_point: List[float] = None)

Function to split a wall vertically based on a given point and possibly direction. If no direction is specified, the normal vector of the wall is used. The point and direction essentially specify a vertical cutting plane that is used to split the wall in two parts.

Note

The direction specifies the direction parallel to the cutting plane, not perpendicular!

Input:

wall (obj): Wall object that needs to be split.
point (list of 3 floats): Point at which the wall must be split vertically. NOTE: This point doesn’t necessarily need to be in plane of the wall, because it’s projected to the wall.
direction (list of 3 floats): Direction in which the point is projected to the wall and parallel direction of the cutting plane that is used to split the wall. If no direction is specified, the normal vector of the wall is used.
reference_point (list of 3 floats): Reference point that should be in the part of the wall that will be the original wall. The other part will be the new wall. If not specified, the new wall will be the smaller part.

Output:

The wall is split in 2 parts, the original wall is adjusted and a new wall is created.
The new wall is part in which the reference point is not found, otherwise it will be the smaller of the 2 parts.
The new wall is returned.

viia_start_interactive_modelling(level: Union[Level, float, str], geometry_material_combinations: List[List[Union[int, float, str]]], layer: Union[Layer, str], grid_lines: Union[Grid, List[Union[Gridline, GridlineGroup, Grid]]] = None, shape_type: str = 'wall', top_level: Optional[Union[Level, float, str]] = None, reference_shapes: List[Union[Shapes, Layer]] = None, create_new_shapes: bool = True, show_pop_up: bool = False, prevent_grid_output: bool = False)

Input:

project (obj): Project object containing collections and of fem objects and project variables.
level (obj): Level object that indicates the level of the new to model shapes. Alternatively the z_coordinate or name of an existing level can be given.
layer (obj): Layer object that indicates the layer of the new to model shapes.
grid_lines (obj): Grid associate objects near the area where new shapes will be modelled. The intersections of the gridlines will be available as clickable points. Default value is None. If None is provided, the first Grid of the project will be used.
geometry_material_combinations (list of lists of two inputs): List of the geometry and material combination that are used for the new shapes. First input of the inner list should be the geometry, Second input should be the material.
shape_type (str): The type of new shapes that can be created. Available are: ‘wall’, ‘floor’, ‘beam’, ‘column’.
top_level (obj): Level that indicates the top of the wall. Required only when shape_type is ‘wall’ or ‘column’, for other shape_type input the top_level is not used. Alternatively the -_coordinate or name of an existing level can be given.
reference_shapes (list of obj): Indicates which references shapes should be shown in the plot to help modelling. When no input is given the shapes from the layer below the layer of the new shapes will be used.
create_new_shapes (bool): Switch to indicate if the new shapes should be made directly.
show_pop_up (bool): Switch to show a pop-up when creating the shapes
prevent_grid_output (bool): If possible the output will be provided for the grid system. With this switch grid based output can be prevented. Default is False.

Output:

The lines to create the shapes in the model script will be printed in the python console.
New shapes will be created when create_new_shapes is set to through
Returned are a list of text lines with commands to create the new shapes, and the object references of the new shapes

property viia_supported_points: List[Shapes]: Returns list of supported shapes that have a point-support.

property viia_supported_surfaces: List[Shapes]: Returns list of supported shapes that have a surface-support.

viia_surface_mass(surface: Surfaces, new_material_name: str, added_mass: float): Sub-function for adding mass to a surface. It will check if already a material exists (only VIIA naming convention), it will check if it can just update the current material object, or that it needs to create a new material.

viia_truss(line_object: Union[Column, Beam]) → bool

Function to make a truss (‘STAAF’) of a beam (‘BALK’). A beam is able to bend, a truss is only able to transfer axial forces.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
line_object (obj): Beam or column that will be changed into a truss.

Output:

The name of the object is slightly changed; ‘BALK’ is replaced with ‘STAAF’
The attribute ‘elementclass_type’ of the object is set to ‘ENHTR3’ (enhanced 3d truss element).
If model is created it will be updated in DIANA.

viia_update_analyses_DIANA_to_ABAQUS()

This function updates the DIANA analysis objects to ABAQUS applicable ones.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

All present analyses in the project are updated or replaced with analysis specified for explicit analysis in ABAQUS, following VIIA workflow.

viia_update_pile_supports_for_rob_test() → List[PointSupport]

This function temporarily adds vertical restraints on the bottom node of the piles. Then the rob-test can be performed which applies a vertical displacement on those nodes. Therefore, it requires a constraint and not a boundary spring. The boundary spring can remain in the model.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

Pointsupports for piles are created constraining the vertical degree of freedom. The name of the support contains the text ‘-temp_for_robtest’. Which is used to have the possibility to remove after the rob-test analysis.

viia_wall_displacements(wall_oop_tbfile: Path, signal: str, wall_list: List[Union[str, Wall]] = None, analysis: Optional[Analysis] = None) → Optional[Tuple[Path, List[Path]]]

This function computes the in-plane and out-of-plane displacements for the walls through all the time steps of the time signal.

Input:

project (obj): Project object containing collections and of fem objects and project variables.
wall_oop_tbfile (Path): Path to the OUTPUT_2.tb file.
signal (str): String representing the signal, can be S1 to S11.
wall_list (list): List of walls as object reference or wall-names as strings to be considered in this function. Default value is None, applying all walls except for the foundation walls.

Output:

The absolute and relative in-plane and out-of-plane displacements for each wall requested in the wall_list (If no wall is specified then all walls are considered) are generated within the OOP_IP_displacements folder in the working folder. The folder and a list of create files are returned in a tuple.

viia_wall_to_columns(ref_width: float = 1.0)

This function converts all walls with a width smaller than the reference width into columns.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
ref_width (float): Maximum width of wall that will be converted to column in [m]. Default value is 1m.

Output:

Walls with a width less than the reference width are deleted and replaced by columns of the same dimension.

viia_walls_split_floor_heights()

Function to split all walls according to the levels of the floors. The function will automatically loop over the wall objects.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.

Output:

The walls are split at the heights of the floors.

Limitation:

This can only be used for rectangular walls

Example:

>>> viia_walls_split_floor_heights()

viia_wooden_beam_floors(floor, start_wall_distance=None, material_beams='LIN-HOUT', material_sheeting='LIN-HOUT', only_beams: bool = False, offset: Optional[float] = None)

This function removes the floor with wooden beams and planks modelled with equivalent properties and replaces it with a floor modelled with beams and a plane. The beams are placed in direction of the local x-axis. The center to center distance is taken from the floor name, also beam dimensions and thickness.

The offset around the slab is set to 0.1m. The material ‘LIN-HOUT’ is coupled to beams and slab.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
floor (obj): Object reference of the floor that needs to be replaced with beams and sheeting. Alternative (str): Name of the floor that needs to be replaced. The floor must be available in PY-memory.
start_wall_distance (float): Distance from start of floor to the first beam. Starting point is the outer point orthogonal to span. Default value is ‘None’.
material_beams (str): Name of the material model to be used for the beams. Default value is ‘LIN-HOUT’.
material_sheeting (str): Name of the material model to be used for the sheeting (planks or sheeting). Default value is ‘LIN-HOUT’.
only_beams (bool): Switch to only create beams and remove the surfaces.
offset (float): Value to offset the contour of the new floor, in [m].

Output:

The floor is replaced in the model with a floor of beams and a slab.

Warning

Material of slab needs to be adjusted (reduced shear stiffness).

Warning

Eccentricity of slab needs to be added.

viia_write_dump(filename: Optional[str] = None, folder: Optional[Path] = None, create_summary: bool = True, result_json_only: bool = False) → Tuple[Optional[Path], Optional[Path], Optional[Path]]

This function writes a dump-file of the current PY-memory. It saves the shapes, its attributes, Project data, properties, etc. The function viia_read_dump can be applied to reload.

Input:

project (obj): VIIA project object containing collections of fem objects and project variables.
filename (str): The name of the json-file to be written, default value is None, creating a filename based on the projectname and extend with ‘-model’.
folder (str or path): The name of the sub-folder where the file is to be written can be given, folder should be available. The sub-folder given in the argument is relative to and in the working directory. If not provided the json will be saved to the ‘model’ folder that is a sub-folder in the working folder.
create_summary (bool): Indicates if a pdf with a model summary should be made. Default is True.
result_json_only (bool): Switch to indicate only the result json should be generated. Only works if results= True, and return_result_json=True. By default, the switch is set to False.

Output:

Dumpfile is created by default in sub-folder ‘model’ of working directory or in given sub-folder of the working directory. The file contains the current state of the model in PY-memory.
Based on the model a summary is created.
A tuple is returned with the location of the model json-file, result json-file and model summary pdf-file.

Create function

viiapackage.viiaStatus.viia_create_project(project_name: str, object_part: str = 'Gehele object', version_nr: int = 1, language: str = 'EN', analysis_type: Optional[str] = None, reference_period: Optional[str] = None, myviia_token: str = None) → ViiaProject[source]

Function sets the name of the project. The start time of the session is recorded. The logfile for the project is created and sets the selected software for the analysis performed for the session. The default directions are created (X-, Y- and Z-direction).

Additional for the VIIA package all the project defaults are set. Project information is collected from MYVIIA webtool. For the reference period and analysis type input may be provided to deviate from the values that are stored in the MYVIIA webtool, this can be done only for analyses. Reporting will use the information from MYVIIA. Make sure that the information on MYVIIA is up-to-date and if information needs to be updated, ask the projectleader to do that.

Input:

project_name (str): Name of the project. This is the object number used in VIIA, for example ‘1234T’.
object_part (str): In case of multiple object parts, select the correct part for this analysis. On MYVIIA you can see which object parts are available. Default value is ‘Gehele object’, which is the name to be used if the object is not split in separate parts on MYVIIA. There can be multiple object-parts for reruns, multiple inspections and objects that are split for analyses (front house vs barn).
version_nr (int): Version number that will be present in the files written by the VIIApackage. Version 1 is reserved for the existing building analysis (NL: ‘Bestaande situatie’), this can be including measures you always require (NL: ‘Zowiezo maatregelen). From version 2 and up the version number indicates additional strengthening steps. The version numbering is used in the automated reporting tool. Default value is 1, referring to existing building model.
language (str): Language selection for the engineering report and figures. Available languages are ‘EN’ for English and ‘NL’ for Dutch. Default value is ‘EN’.
analysis_type (str): If you want to deviate from the analysis type on the MYVIIA tool you can select the type of analysis to be performed. Within VIIA currently ‘MRS’, ‘NLTH’ and ‘NLPO’ are available. Default value is None. When another analysis-type is selected, you can perform analysis, but reporting is not possible.
reference_period (str): If you want to deviate from the reference period on the MYVIIA tool you can select the reference period for which the peak ground acceleration is determined. In that case select from ‘t1’, ‘t2’, ‘t3’, ‘t4’, ‘t5’ or ‘t6’. Default value is None.
myviia_token (str): Optional input to provide the token for access to MYVIIA database. Input only used when script is performed on MYVIIA server environment.

Output:

The projectname and related items are set in the ‘Project’ class.
Project information is collected from MYVIIA webtool.
A logfile for this session is created.
A check is performed if the correct version of the DIANA software is used (complying to the latest BoD).
Returns the VIIA project object.

ViiaSettings

This class contains all project settings for the VIIA project. They are defined in the UPR and deviating is advised against.

class viiapackage.viiaStatus.ViiaSettings(language: str = 'NL')[source]

Bases: object

This class contains all the VIIA specific information.

__init__(language: str = 'NL')[source]

Input:

language (str): Language selection for the engineering report and figures. Available languages are ‘EN’ for English and ‘NL’ for Dutch. Default value is ‘NL’.

static output_steps(output_name: str, nr_steps: Optional[int] = None) → str[source]: Static method of ‘ViiaSettings’ to get the default output-steps required for NLTH analysis. Including dependency on the length of the signal (number of steps).

BaseSignals

This class contains the base signals that are used to calculate the applied signals from.

Get project info from MYVIIA

When the VIIA project is created, all required information from MYVIIA is collected and stored in the instance. This is done with the following function:

General functionality for the database connection:

viiapackage.database.viia_myviia._viia_get_from_myviia(url: str, token: str, stream: bool = False)[source]: Function to create GET request to retrieve data from MYVIIA tool.

viiapackage.database.viia_myviia._viia_post_to_myviia(url: str, token: str, data: dict)[source]: Function to create POST request to enter new data record to MYVIIA tool.

viiapackage.database.viia_myviia.myviia_check_modules(func)[source]: This function checks if all required 3rd party modules are installed properly when collecting data from MYVIIA webtool.

viiapackage.database.viia_myviia.myviia_login() → str[source]

This function connects to the MYVIIA database, provides authentication and returns a bearer token to acccess the database for additional requests. Note that the token lifecycle is limited.

Note

Credentials should be stored in the user-config file. Do not save credentials in scripts.

Input:

No input required.

Output:

If successful authentication is performed, the token is returned as string.
Error is raised if any problem occurs.

viiapackage.database.viia_myviia.myviia_token(func)[source]: This function checks if token is provided or that it should be collected with login.

Connecting for pile information is done with: