class viktor.external.scia.scia.SciaAnalysis(input_file, xml_def_file, scia_model, calculation_setting=CalcSetting.LIN, xml_doc_name='output', *, result_type=ResultType.MODEL, output_document='')¶

Bases: ExternalProgram

SciaAnalysis can be used to perform an analysis using SCIA on a third-party worker. To start an analysis call the method execute(), with an appropriate timeout (in seconds). To retrieve the output file call the method get_xml_output_file() after execute().

Usage:

input_file = BytesIO("scia input file content".encode())
xml_def_file = BytesIO("scia xml def file content".encode())
scia_model = BytesIO("scia model content".encode())
scia_analysis = SciaAnalysis(input_file=input_file, xml_def_file=xml_def_file, scia_model=scia_model)
scia_analysis.execute(timeout=600)
xml_output_file = scia_analysis.get_xml_output_file()

Besides the output XML file, you can also retrieve the updated SCIA model. This is achieved using the result_type:

scia_analysis = SciaAnalysis(input_file=input_file, xml_def_file=xml_def_file, scia_model=scia_model,
                             result_type=ResultType.MODEL)
scia_analysis.execute(timeout=600)
updated_esa_file = scia_analysis.get_updated_esa_model()

or the Engineering Report:

scia_analysis = SciaAnalysis(input_file=input_file, xml_def_file=xml_def_file, scia_model=scia_model,
                             result_type=ResultType.ENGINEERING_REPORT, output_document='report1')
scia_analysis.execute(timeout=600)
engineering_report = scia_analysis.get_engineering_report()

Exceptions which can be raised during calculation:

viktor.errors.LicenseError: no license available

viktor.errors.ExecutionError: generic error. Error message provides more information

Parameters

input_file (Union[BytesIO, File]) – SCIA input .xml file.
xml_def_file (Union[BytesIO, File]) – SCIA input .def file.
scia_model (Union[BytesIO, File]) – SCIA .esa model.
calculation_setting (CalcSetting) –
Available calculation settings according to the documentation of ESA_XML.exe:
- NONE = without any recalculations
- NOC = No calculation
- LIN = Linear calculation (Delete all calculated results when exists)
- NEL = Nonlinear calculation
- CON = Nonlinear concrete calculation
- EIG = Eigen frequencies calculation
- STB = Stability calculation
- INF = Influence lines calculation
- MOB = Mobile loads calculation
- TDA = TDA calculation
- SLN = Soilin calculation
- PHA = Phases calculation
- NPH = Nonlinear phases
- CSS = Recalculation of cross sections
- NST = Nonlinear stability
- TID = Test of input data - solver link only
xml_doc_name (str) – Name of XML IO document for export.
result_type (ResultType) –
Type of output which should be returned besides the output.xml:
- ResultType.NONE returns nothing
- ResultType.MODEL returns the updated SCIA model (.esa) after calculation
- ResultType.ENGINEERING_REPORT returns the specified engineering report
output_document (str) – Document name of the report which should be returned. This name should match the exact name of the report as defined in the .esa model.

Raises

ValueError – if Engineering Report is selected as result_type, but no output_document is specified.

static get_xml_def_name(input_file)¶

Return type: str

get_xml_output_file(as_file=False)¶

Method can be used to retrieve the results generated by running an external analysis. This method returns the output XML file that is generated by SCIA. Make sure to call method execute() first and get_xml_output_file() afterwards.

Return type

Union[BytesIO, File, None]

Returns

File, if as_file = True
BytesIO, if as_file = False (default)

get_updated_esa_model(as_file=False)¶

Method can be used to retrieve the updated SCIA model file (.esa), which contains the data that is read into the model while calling ESA_XML.exe. Make sure to call method execute() first and get_updated_esa_model() afterwards.

Return type

Union[BytesIO, File, None]

Returns

File, if as_file = True
BytesIO, if as_file = False (default)

get_engineering_report(as_file=False)¶

Method can be used to retrieve the Engineering Report (.pdf). Make sure to call method execute() first and get_engineering_report() afterwards.

Return type

Union[BytesIO, File, None]

Returns

File, if as_file = True
BytesIO, if as_file = False (default)

Model

class viktor.external.scia.scia.Model(*, mesh_setup=None, solver_setup=None, project_data=None)¶

This Model can be used to construct a SCIA model and generate its corresponding input XML file. This file can in turn be used as input of SciaAnalysis. For a more detailed elaboration, please see the tutorial.

Example usage:

# Initialize the model
model = Model()

# Construct the geometry
n1 = model.create_node('K:1', 0, 0, 0)
n2 = model.create_node('K:2', 1, 0, 0)
css = model.create_circular_cross_section('css', Material(123, 'some_material'), 100)
beam = model.create_beam(n1, n2, css)

#Construct the boundary conditions
freedom = (PointSupport.Freedom.RIGID, PointSupport.Freedom.RIGID, PointSupport.Freedom.RIGID,
    PointSupport.Freedom.RIGID, PointSupport.Freedom.RIGID, PointSupport.Freedom.RIGID)
model.create_point_support('Sn1', n1, PointSupport.Type.STANDARD, freedom, (0, 0, 0, 0, 0, 0),
    PointSupport.CSys.GLOBAL)

# Construct a load combination
load_group = model.create_load_group('LG1', LoadGroup.LoadOption.VARIABLE, LoadGroup.RelationOption.STANDARD,
    LoadGroup.LoadTypeOption.CAT_A)
load_case = model.create_variable_load_case('LC1', 'My first load case', load_group,
    LoadCase.VariableLoadType.STATIC, LoadCase.Specification.STANDARD, LoadCase.Duration.SHORT)
model.create_load_combination('C1', LoadCombination.Type.ENVELOPE_ULTIMATE, {load_case: 1})

# Generate the input XML file
input_xml = model.generate_xml_input()

Parameters

mesh_setup (Optional[MeshSetup]) – Optional mesh settings.
solver_setup (Optional[SolverSetup]) – Optional solver settings
New in v13.1.0
.
project_data (Optional[ProjectData]) – Optional project settings
New in v13.1.0
.

property layers: Tuple[Layer, ...]¶

Return type: Tuple[Layer, ...]

property concrete_materials: Tuple[Concrete, ...]¶

Return type: Tuple[Concrete, ...]

property nonlinear_functions: Tuple[NonLinearFunction, ...]¶

Return type: Tuple[NonLinearFunction, ...]

property subsoils: Tuple[Subsoil, ...]¶

Return type: Tuple[Subsoil, ...]

property orthotropy_objects: Tuple[Orthotropy, ...]¶

Return type: Tuple[Orthotropy, ...]

property cross_sections: Tuple[CrossSection, ...]¶

Return type: Tuple[CrossSection, ...]

property nodes: Tuple[Node, ...]¶

Return type: Tuple[Node, ...]

property beams: Tuple[Beam, ...]¶

Return type: Tuple[Beam, ...]

property cross_links: Tuple[CrossLink, ...]¶

New in v13.1.0

Return type: Tuple[CrossLink, ...]

property arbitrary_profiles: Tuple[ArbitraryProfile, ...]¶

Return type: Tuple[ArbitraryProfile, ...]

property hinges_on_beam: Tuple[HingeOnBeam, ...]¶

Return type: Tuple[HingeOnBeam, ...]

property hinges_on_plane: Tuple[HingeOnPlane, ...]¶

Return type: Tuple[HingeOnPlane, ...]

property sections_on_beam: Tuple[SectionOnBeam, ...]¶

Return type: Tuple[SectionOnBeam, ...]

property sections_on_plane: Tuple[SectionOnPlane, ...]¶

Return type: Tuple[SectionOnPlane, ...]

property planes: Tuple[Plane, ...]¶

Return type: Tuple[Plane, ...]

property open_slabs: Tuple[OpenSlab, ...]¶

Return type: Tuple[OpenSlab, ...]

property internal_edges: Tuple[InternalEdge, ...]¶

Return type: Tuple[InternalEdge, ...]

property rigid_arms: Tuple[RigidArm, ...]¶

Return type: Tuple[RigidArm, ...]

property point_supports: Tuple[PointSupport, ...]¶

Return type: Tuple[PointSupport, ...]

property point_supports_line: Tuple[PointSupportLine, ...]¶

Return type: Tuple[PointSupportLine, ...]

property line_supports_line: Tuple[LineSupportLine, ...]¶

Return type: Tuple[LineSupportLine, ...]

property line_supports_surface: Tuple[LineSupportSurface, ...]¶

Return type: Tuple[LineSupportSurface, ...]

property surface_supports: Tuple[SurfaceSupportSurface, ...]¶

Return type: Tuple[SurfaceSupportSurface, ...]

property load_cases: Tuple[LoadCase, ...]¶

Return type: Tuple[LoadCase, ...]

property load_groups: Tuple[LoadGroup, ...]¶

Return type: Tuple[LoadGroup, ...]

property load_combinations: Tuple[LoadCombination, ...]¶

Return type: Tuple[LoadCombination, ...]

property nonlinear_load_combinations: Tuple[NonLinearLoadCombination, ...]¶

Return type: Tuple[NonLinearLoadCombination, ...]

property result_classes: Tuple[ResultClass, ...]¶

Return type: Tuple[ResultClass, ...]

property point_loads_node: Tuple[PointLoadNode, ...]¶

Return type: Tuple[PointLoadNode, ...]

property point_loads: Tuple[PointLoad, ...]¶

Return type: Tuple[PointLoad, ...]

property point_moments_node: Tuple[PointMomentNode, ...]¶

Return type: Tuple[PointMomentNode, ...]

property line_loads: Tuple[LineLoad, ...]¶

Return type: Tuple[LineLoad, ...]

property line_moments_on_beam: Tuple[LineMomentOnBeam, ...]¶

Return type: Tuple[LineMomentOnBeam, ...]

property line_moments_on_plane: Tuple[LineMomentOnPlane, ...]¶

Return type: Tuple[LineMomentOnPlane, ...]

property line_force_surface_list: Tuple[LineForceSurface, ...]¶

Return type: Tuple[LineForceSurface, ...]

property surface_loads: Tuple[SurfaceLoad, ...]¶

Return type: Tuple[SurfaceLoad, ...]

property thermal_loads: Tuple[ThermalLoad, ...]¶

Return type: Tuple[ThermalLoad, ...]

property thermal_surface_loads: Tuple[ThermalSurfaceLoad, ...]¶

Return type: Tuple[ThermalSurfaceLoad, ...]

property free_surface_loads: Tuple[FreeSurfaceLoad, ...]¶

Return type: Tuple[FreeSurfaceLoad, ...]

property free_line_loads: Tuple[FreeLineLoad, ...]¶

Return type: Tuple[FreeLineLoad, ...]

property free_point_loads: Tuple[FreePointLoad, ...]¶

Return type: Tuple[FreePointLoad, ...]

property integration_strips: Tuple[IntegrationStrip, ...]¶

Return type: Tuple[IntegrationStrip, ...]

property mesh_setup: MeshSetup¶

Return type: MeshSetup

property solver_setup: SolverSetup¶

New in v13.1.0

Return type: SolverSetup

property project_data: ProjectData¶

New in v13.1.0

Return type: ProjectData

create_layer(name=None, *, comment=None, structural_model_only=None, current_used_activity=None)¶

Method to construct a layer.

Duplicate layer names are not allowed.

Parameters

name (Optional[str]) – name of the layer (default: ‘Layer{i}’)
comment (Optional[str]) – optional comment
structural_model_only (Optional[bool]) – when ‘True’, the layer is NOT taken into account for the calculation (default: False)
current_used_activity (Optional[bool]) – defines if the layer is visible or not on the screen (default: True)

Return type

Layer

update_concrete_material(object_id, name, part, thermal_expansion=None, unit_mass=None, wet_density=None, e_modulus=None, poisson=None, g_modulus=None, log_decrement=None, specific_heat=None, thermal_conductivity=None, *, fck=None)¶

This method can update specific properties of an already existing concrete material in the *.esa model.

Parameters

object_id (int) – id of the material in SCIA
name (str) – name which will be shown in SCIA
part (ECPart) – enumeration of concrete types
thermal_expansion (Optional[float]) – thermal expansion in [m/mK]
unit_mass (Optional[float]) – density in [kg/m³]
wet_density (Optional[float]) – wet density in [kg/m³]
e_modulus (Optional[float]) – Young’s modulus in [Pa]
poisson (Optional[float]) – Poisson ratio
g_modulus (Optional[float]) – shear modulus in [Pa]
log_decrement (Optional[float]) – log. decrement
specific_heat (Optional[float]) – specific heat in [J/kgK]
thermal_conductivity (Optional[float]) – thermal conductivity in [W/mK]
fck (Optional[float]) – characteristic compressive cylinder strength [Pa]

Return type

Concrete

create_nonlinear_function(name, function_type, positive_end, negative_end, impulse)¶

Method to construct a non-linear function.

Parameters

name (str) – name of the function
function_type (Type) – type of function
positive_end (Support) – type of support at positive end
negative_end (Support) – type of support at negative end
impulse (List[Tuple[float, float]]) – impulse function X-Y values in [m, N] (if function_type = TRANSLATION), [rad, Nm] (if function_type = ROTATION), or [m, Pa] (if function_type = NONLINEAR_SUBSOIL)

Return type

NonLinearFunction

create_subsoil(name, *, stiffness, c1x=None, c1y=None, c1z=None, nonlinear_function=None, c2x=None, c2y=None, is_drained=None, water_air_in_clay_subgrade=None, specific_weight=None, fi=None, sigma_oc=None, c=None, cu=None)¶

Method to construct a subsoil.

Parameters

name (str) – name of the subsoil
stiffness (float) – stiffness c1z [N/m3]
c1x (Optional[float]) – stiffness c1x [N/m3] (default: 50000000)
c1y (Optional[float]) – stiffness c1y [N/m3] (default: 50000000)
c1z (Optional[C1z]) – type for c1z (default: FLEXIBLE)
nonlinear_function (Optional[NonLinearFunction]) – nonlinear function (create_nonlinear_function()) (c1z = NONLINEAR_FUNCTION only)
c2x (Optional[float]) – [N/m]
c2y (Optional[float]) – [N/m]
is_drained (Optional[bool]) – True for ‘drained’, False for ‘undrained’ (default: False)
water_air_in_clay_subgrade (Optional[bool]) – (default: False)
specific_weight (Optional[float]) – specific weight [kg/m3] (default: 0.0)
fi (Optional[float]) – fi’ [deg] (default: 0.0)
sigma_oc (Optional[float]) – sigma oc [Pa] (default: 0.0)
c (Optional[float]) – c’ [Pa] (default: 0.0)
cu (Optional[float]) – [Pa] (default: 0.0)

Return type

Subsoil

create_orthotropy(name, material, thickness, D11=None, D22=None, D12=None, D33=None, D44=None, D55=None, d11=None, d22=None, d12=None, d33=None, kxy=None, kyx=None)¶

Method to construct a type of orthotropy.

Parameters

name (str) – name of the orthotropy
material (Material) – material
thickness (float) – thickness of the plate / wall [m]
D11 (Optional[float]) – (plate) stiffness matrix parameter [Nm]
D22 (Optional[float]) – (plate) stiffness matrix parameter [Nm]
D12 (Optional[float]) – (plate) stiffness matrix parameter [Nm]
D33 (Optional[float]) – (plate) stiffness matrix parameter [Nm]
D44 (Optional[float]) – (plate) stiffness matrix parameter [N/m]
D55 (Optional[float]) – (plate) stiffness matrix parameter [N/m]
d11 (Optional[float]) – (membrane) stiffness matrix parameter [N/m]
d22 (Optional[float]) – (membrane) stiffness matrix parameter [N/m]
d12 (Optional[float]) – (membrane) stiffness matrix parameter [N/m]
d33 (Optional[float]) – (membrane) stiffness matrix parameter [N/m]
kxy (Optional[float]) – stiffness coefficient [N/m]
kyx (Optional[float]) – stiffness coefficient [N/m]

Return type

Orthotropy

create_arbitrary_profile_span(length, type_of_css, cross_section_start, cross_section_end, alignment)¶

Method to construct an arbitrary profile span, which is necessary to construct an arbitrary profile.

Parameters

length (float) – length of the span
type_of_css (TypeOfCss) – enumeration of cross-section types
cross_section_start (CrossSection) – previously created cross-section object at the start point
cross_section_end (CrossSection) – previously created cross-section object at the end point
alignment (Alignment) – enumeration of alignment types

Return type

ArbitraryProfileSpan

create_rectangular_cross_section(name, material, width, height)¶

Method to construct a rectangular cross-section.

Parameters

name (str) – name which will be shown in SCIA
material (Material) – material of the cross-section
width (float) – width of the cross-section in [m]
height (float) – height of the cross-section in [m]

Return type

RectangularCrossSection

create_circular_cross_section(name, material, diameter)¶

Method to construct a circular cross-section.

Parameters

name (str) – name which will be shown in SCIA
material (Material) – material of the cross-section
diameter (float) – diameter of the cross-section in [m]

Return type

CircularCrossSection

create_circular_hollow_cross_section(name, material, diameter, thickness)¶

Method to construct a circular hollow cross-section.

Parameters

name (str) – name which will be shown in SCIA
material (Material) – material of the cross-section
diameter (float) – diameter of the cross-section in [m]
thickness (float) – thickness in [m]

Return type

CircularHollowCrossSection

create_circular_composed_cross_section(name, material, material_2, diameter, thickness)¶

Method to construct a circular cross-section, composed of two materials.

Parameters

name (str) – name which will be shown in SCIA
material (Material) – outer material of the cross-section
material_2 (Material) – inner material of the cross-section
diameter (float) – diameter of the cross-section in [m]
thickness (float) – thickness in [m]

Return type

CircularComposedCrossSection

create_numerical_cross_section(name, material, *, A=None, Ay=None, Az=None, AL=None, AD=None, cYUCS=None, cZUCS=None, alpha=None, Iy=None, Iz=None, Wely=None, Welz=None, Wply=None, Wplz=None, Mply_plus=None, Mply_min=None, Mplz_plus=None, Mplz_min=None, dy=None, dz=None, It=None, Iw=None, beta_y=None, beta_z=None)¶

Method to construct a numerical cross-section.

Parameters

name (str) – name which will be shown in SCIA
material (Material) – material of the cross-section
A (Optional[float]) – cross-sectional area [m²]
Ay (Optional[float]) – shear area in y-direction [m²]
Az (Optional[float]) – shear area in z-direction [m²]
AL (Optional[float]) – circumference per unit length [m²/m]
AD (Optional[float]) – drying surface per unit length [m²/m]
cYUCS (Optional[float]) – centroid in y-direction of input axis system [mm]
cZUCS (Optional[float]) – centroid in z-direction of input axis system [mm]
alpha (Optional[float]) – rotation angle of axis system [deg]
Iy (Optional[float]) – moment of inertia about the y-axis [m⁴]
Iz (Optional[float]) – moment of inertia about the z-axis [m⁴]
Wely (Optional[float]) – elastic section modulus about the y-axis [m³]
Welz (Optional[float]) – elastic section modulus about the z-axis [m³]
Wply (Optional[float]) – plastic section modulus about the y-axis [m³]
Wplz (Optional[float]) – plastic section modulus about the z-axis [m³]
Mply_plus (Optional[float]) – plastic moment about the y-axis for positive My moment [Nm]
Mply_min (Optional[float]) – plastic moment about the y-axis for negative My moment [Nm]
Mplz_plus (Optional[float]) – plastic moment about the z-axis for positive My moment [Nm]
Mplz_min (Optional[float]) – plastic moment about the z-axis for negative My moment [Nm]
dy (Optional[float]) – shear center coordinate in y-axis, measured from centroid [mm]
dz (Optional[float]) – shear center coordinate in z-axis, measured from centroid [mm]
It (Optional[float]) – torsional constant [m⁴]
Iw (Optional[float]) – warping constant [m⁶]
beta_y (Optional[float]) – mono-symmetry constant about the y-axis [mm]
beta_z (Optional[float]) – mono-symmetry constant about the z-axis [mm]

Return type

NumericalCrossSection

create_library_cross_section(section, profile, material, *, name=None)¶

New in v13.1.0

Method to construct a cross-section that is part of the cross-section library.

Parameters

section (Section) – section type (e.g. LibraryCrossSection.Section.I)
profile (str) – profile name including dimensions (e.g. “SHS30/30/2.0”)
material (Material) – material of the cross-section
name (Optional[str]) – name of the cross-section (default: ‘CS{i}’)

Return type

LibraryCrossSection

create_node(name, x, y, z)¶

Method to construct a node.

Parameters

name (str) – name which will be shown in SCIA
x (float) – X-coordinate in [m]
y (float) – Y-coordinate in [m]
z (float) – Z-coordinate in [m]

Return type

Node

create_beam(begin_node, end_node, cross_section, *, name=None, ez=None, lcs_rotation=None, layer=None)¶

Method to construct a beam.

Parameters

begin_node (Node) – node object (create_node()) at the start of the beam.
end_node (Node) – node object (create_node()) at the end of the beam.
cross_section (CrossSection) – previously created cross-section object
name (Optional[str]) – name which will be shown in SCIA (default: ‘B{i}’)
ez (Optional[float]) – eccentricity in Z-direction w.r.t. the beam’s center line in [m] (default: 0)
lcs_rotation (Optional[float]) – rotation of local coordinate system [deg] (default: 0)
layer (Optional[Layer]) – layer object (create_layer()) to which the beam will be added

Return type

Beam

create_cross_link(beam_1, beam_2, *, name=None)¶

New in v13.1.0

Method to construct a cross-link, connecting two beams.

Parameters

beam_1 (Beam) – first beam (create_beam())
beam_2 (Beam) – second beam (create_beam())
name (Optional[str]) – name which will be shown in SCIA (default: ‘CL{i}’)

Return type

CrossLink

create_arbitrary_profile(name, beam, c_def, cross_section, spans)¶

Method to construct an arbitrary profile.

Parameters

name (str) – name which will be shown in SCIA
beam (Beam) – beam object (create_beam()).
c_def (CDef) – enumeration of coordinate definition types
cross_section (CrossSection) – previously created cross-section object
spans (List[ArbitraryProfileSpan]) – list of arbitrary profile span objects (create_arbitrary_profile_span()).

Return type

ArbitraryProfile

create_hinge_on_beam(beam, position, *, name=None, freedom_ux=Freedom.RIGID, freedom_uy=Freedom.RIGID, freedom_uz=Freedom.RIGID, freedom_fix=Freedom.RIGID, freedom_fiy=Freedom.FREE, freedom_fiz=Freedom.RIGID, stiffness_ux=0, stiffness_uy=0, stiffness_uz=0, stiffness_fix=0, stiffness_fiy=0, stiffness_fiz=0)¶

Create a hinge on a beam.

Parameters

beam (Beam) – Beam of appliance (create_beam()).
position (Position) – Position of appliance.
name (Optional[str]) – Name of the hinge (default: ‘H{i}’).
freedom_ux (Freedom) – Freedom in ux (default: rigid).
freedom_uy (Freedom) – Freedom in uy (default: rigid).
freedom_uz (Freedom) – Freedom in uz (default: rigid).
freedom_fix (Freedom) – Freedom in fix (default: rigid).
freedom_fiy (Freedom) – Freedom in fiy (default: free).
freedom_fiz (Freedom) – Freedom in fiz (default: rigid).
stiffness_ux (float) – Stiffness in ux [N/m], only used if freedom in ux = flexible (default: 0.0).
stiffness_uy (float) – Stiffness in uy [N/m], only used if freedom in uy = flexible (default: 0.0).
stiffness_uz (float) – Stiffness in uz [N/m], only used if freedom in uz = flexible (default: 0.0).
stiffness_fix (float) – Stiffness in fix [Nm/rad], only used if freedom in fix = flexible (default: 0.0).
stiffness_fiy (float) – Stiffness in fiy [Nm/rad], only used if freedom in fiy = flexible (default: 0.0).
stiffness_fiz (float) – Stiffness in fiz [Nm/rad], only used if freedom in fiz = flexible (default: 0.0).

Return type

HingeOnBeam

create_section_on_beam(name, beam, c_def, position_x, origin, repeat, delta_x)¶

Method to construct a section on a beam, which can be used to receive calculation results on its position.

Parameters

name (str) – name which will be shown in SCIA
beam (Beam) – beam object (create_beam()).
c_def (CDef) – enumeration of coordinate definition types
position_x (float) – position of the section on the beam
origin (Origin) – enumeration of origin types
repeat (int) – number of section defined at the same time
delta_x (float) – if repeat is greater than 1, this value defines the distance between individual sections

Return type

SectionOnBeam

create_section_on_plane(point_1, point_2, *, name, draw=None, direction_of_cut=None)¶

Method to construct a section on a plane, which can be used to receive calculation results on its position.

Parameters

point_1 (Tuple[float, float, float]) – tuple of coordinates (x, y, z) of the start position in [m]
point_2 (Tuple[float, float, float]) – tuple of coordinates (x, y, z) of the end position in [m]
name (str) – name which will be shown in SCIA (default: SE{i})
draw (Optional[Draw]) – defines the plane in which the section is drawn (default: Z_DIRECTION)
direction_of_cut (Optional[Tuple[float, float, float]]) – in-plane vector (x, y, z) which defines the direction of cut in [m] (default: (0, 0, 1))

Return type

SectionOnPlane

create_rigid_arm(name, master_node, slave_node, hinge_on_master, hinge_on_slave)¶

Method to construct a rigid arm.

Parameters

name (str) – name which will be shown in SCIA
master_node (Node) – node object (create_node()).
slave_node (Node) – node object (create_node()).
hinge_on_master (bool) – True to insert a hinge on the master node
hinge_on_slave (bool) – True to insert a hinge on the slave node

Return type

RigidArm

create_plane(corner_nodes, thickness, *, material, name=None, plane_type=None, layer=None, internal_nodes=None, swap_orientation=None, lcs_rotation=None, fem_model=None, orthotropy=None)¶

Method to construct a 2D member.

Parameters

corner_nodes (List[Node]) – list of node objects located at the corners
thickness (float) – thickness of the plane in [m]
material (Material) – Material of the plane
name (Optional[str]) – name which will be shown in SCIA (default: ‘S{i}’)
plane_type (Optional[Type]) – enumeration of plane types (default: PLATE)
layer (Optional[Layer]) – layer object (create_layer()) to which the plane will be added
internal_nodes (Optional[List[Node]]) – list of internal node objects (default: None)
swap_orientation (Optional[bool]) – whereas to swap the plate orientation (default: False)
lcs_rotation (Optional[float]) – rotation of the local coordinate system [deg] (default: 0.0)
fem_model (Optional[FEMModel]) – FEM model to be used in the calculation (default: isotropic)
orthotropy (Optional[Orthotropy]) – type of orthotropy (only for fem_model = ORTHOTROPIC)

Return type

Plane

create_circular_plane(center_node, diameter, thickness, *, material, axis=None, name=None, plane_type=None, layer=None, internal_nodes=None, swap_orientation=None, lcs_rotation=None, fem_model=None, orthotropy=None)¶

Method to construct a circular 2D member.

Parameters

center_node (Node) – node object (create_node()) located at the center of the plane
diameter (float) – diameter of the plane [m]
thickness (float) – thickness of the plane [m]
material (Material) – Material of the plane
axis (Union[Vector, Tuple[float, float, float], None]) – axis direction (default: (0, 0, 1))
name (Optional[str]) – name which will be shown in SCIA (default: ‘S{i}’)
plane_type (Optional[Type]) – enumeration of plane types (default: PLATE)
layer (Optional[Layer]) – layer object (create_layer()) to which the plane will be added
internal_nodes (Optional[List[Node]]) – list of internal node objects (default: None)
swap_orientation (Optional[bool]) – whereas to swap the plate orientation (default: False)
lcs_rotation (Optional[float]) – rotation of the local coordinate system [deg] (default: 0.0)
fem_model (Optional[FEMModel]) – FEM model to be used in the calculation (default: isotropic)
orthotropy (Optional[Orthotropy]) – type of orthotropy (only for fem_model = ORTHOTROPIC)

Return type

Plane

create_open_slab(name, plane, corner_nodes)¶

Method to construct an open slab in a 2D member.

Parameters

name (str) – name which will be shown in SCIA
plane (Plane) – plane object (create_plane()).
corner_nodes (List[Node]) – list of node objects located at the corners

Return type

OpenSlab

create_internal_edge(plane, node_1, node_2, *, name=None)¶

Method to construct an internal edge in a 2D member.

Parameters

plane (Plane) – plane object (create_plane())
node_1 (Node) – node object (create_node()) at the start of the edge
node_2 (Node) – node object (create_node()) at the end of the edge
name (Optional[str]) – name which will be shown in SCIA (default: ‘ES{i}’)

Return type

InternalEdge

create_integration_strip(plane, point_1, point_2, width)¶

Method to construct an integration strip, which can be used to receive calculation results on its position.

Parameters

plane (Plane) – plane object (create_plane()).
point_1 (Tuple[float, float, float]) – tuple of coordinates (x, y, z) of the start position in [m]
point_2 (Tuple[float, float, float]) – tuple of coordinates (x, y, z) of the end position in [m]
width (float) – width of the strip in [m]

Return type

IntegrationStrip

create_point_support(name, node, spring_type, freedom, stiffness, c_sys, default_size=0.2, *, angle=None)¶

Method to construct a point support.

Parameters

name (str) – name which will be shown in SCIA
node (Node) – node object (create_node()) to which the support will be attached.
spring_type (Type) – enumeration of spring types
freedom (Tuple[Freedom, Freedom, Freedom, Freedom, Freedom, Freedom]) – tuple of component constraints in the order (X, Y, Z, Rx, Ry, Rz)
stiffness (Tuple[float, float, float, float, float, float]) – tuple of component stiffness in the order (X, Y, Z, Rx, Ry, Rz) in [N/m]
c_sys (CSys) – enumeration of coordinate system types
default_size (float) – default size in [m]
angle (Optional[Tuple[float, float, float]]) – angle (Rx, Ry, Rz) [deg] of the support around the respective global X-, Y- and Z-axis

Return type

PointSupport

create_point_support_on_beam(beam, *, name=None, x=None, stiffness_x=None, y=None, stiffness_y=None, z=None, stiffness_z=None, rx=None, stiffness_rx=None, ry=None, stiffness_ry=None, rz=None, stiffness_rz=None, default_size=None, c_sys=None, c_def=None, position_x=None, origin=None, repeat=None, delta_x=None)¶

Method to construct a point support on a beam.

Parameters

beam (Beam) – beam object (create_beam()) to which the line support will be applied
name (Optional[str]) – name which will be shown in SCIA (default: ‘Sb{i}’)
x (Optional[Freedom]) – constraint type in X-direction (default: RIGID)
stiffness_x (Optional[float]) – stiffness in X-direction [N/m] (only for x = FLEXIBLE)
y (Optional[Freedom]) – constraint type in Y-direction (default: RIGID)
stiffness_y (Optional[float]) – stiffness in Y-direction [N/m] (only for y = FLEXIBLE)
z (Optional[Freedom]) – constraint type in Z-direction (default: RIGID)
stiffness_z (Optional[float]) – stiffness in Z-direction [N/m] (only for z = FLEXIBLE)
rx (Optional[Freedom]) – constraint type in X-rotation (default: RIGID)
stiffness_rx (Optional[float]) – stiffness in X-rotation [Nm/rad] (only for rx = FLEXIBLE)
ry (Optional[Freedom]) – constraint type in Y-rotation (default: RIGID)
stiffness_ry (Optional[float]) – stiffness in Y-rotation [Nm/rad] (only for ry = FLEXIBLE)
rz (Optional[Freedom]) – constraint type in Z-rotation (default: RIGID)
stiffness_rz (Optional[float]) – stiffness in Z-rotation [Nm/rad] (only for rz = FLEXIBLE)
default_size (Optional[float]) – size of the support [m] (default: 0.2)
c_sys (Optional[CSys]) – coordinate system (default: GLOBAL)
c_def (Optional[CDef]) – c_def: coordinate definition (default: RELATIVE)
position_x (Optional[float]) – position of the load ([m] if c_def = ABSOLUTE, else [-]) (default: 0)
origin (Optional[Origin]) – reference for position_x (default: FROM_START)
repeat (Optional[int]) – number of uniformly distributed supports (default: 1)
delta_x (Optional[float]) – distance between supports ([m] if c_def = ABSOLUTE, else [-]) (only for repeat > 1)

Return type

PointSupportLine

create_line_support_on_beam(beam, *, name=None, x=None, stiffness_x=None, function_x=None, y=None, stiffness_y=None, function_y=None, z=None, stiffness_z=None, function_z=None, rx=None, stiffness_rx=None, function_rx=None, ry=None, stiffness_ry=None, function_ry=None, rz=None, stiffness_rz=None, function_rz=None, c_sys=None, extent=None, c_def=None, position_x1=None, position_x2=None, origin=None)¶

Method to construct a line support on a beam.

Parameters

beam (Beam) – beam object (create_beam()) to which the line support will be applied
name (Optional[str]) – name which will be shown in SCIA (default: ‘Slb{i}’)
x (Optional[Freedom]) – constraint type in X-direction (default: RIGID)
stiffness_x (Optional[float]) – stiffness in X-direction [N/m2] (only for x = FLEXIBLE | FLEXIBLE_PRESS_ONLY | FLEXIBLE_TENSION_ONLY | NONLINEAR)
function_x (Optional[NonLinearFunction]) – non-linear function in X-direction (only for x = NONLINEAR)
y (Optional[Freedom]) – constraint type in Y-direction (default: RIGID)
stiffness_y (Optional[float]) – stiffness in Y-direction [N/m2] (only for y = FLEXIBLE | FLEXIBLE_PRESS_ONLY | FLEXIBLE_TENSION_ONLY | NONLINEAR)
function_y (Optional[NonLinearFunction]) – non-linear function in Y-direction (only for y = NONLINEAR)
z (Optional[Freedom]) – constraint type in Z-direction (default: RIGID)
stiffness_z (Optional[float]) – stiffness in Z-direction [N/m2] (only for z = FLEXIBLE | FLEXIBLE_PRESS_ONLY | FLEXIBLE_TENSION_ONLY | NONLINEAR)
function_z (Optional[NonLinearFunction]) – non-linear function in Z-direction (only for z = NONLINEAR)
rx (Optional[Freedom]) – constraint type in X-rotation (default: RIGID)
stiffness_rx (Optional[float]) – stiffness in X-rotation [Nm/m/rad] (only for rx = FLEXIBLE | NONLINEAR)
function_rx (Optional[NonLinearFunction]) – non-linear function in X-rotation (only for rx = NONLINEAR)
ry (Optional[Freedom]) – constraint type in Y-rotation (default: RIGID)
stiffness_ry (Optional[float]) – stiffness in Y-rotation [Nm/m/rad] (only for ry = FLEXIBLE | NONLINEAR)
function_ry (Optional[NonLinearFunction]) – non-linear function in Y-rotation (only for ry = NONLINEAR)
rz (Optional[Freedom]) – constraint type in Z-rotation (default: RIGID)
stiffness_rz (Optional[float]) – stiffness in Z-rotation [Nm/m/rad] (only for rz = FLEXIBLE | NONLINEAR)
function_rz (Optional[NonLinearFunction]) – non-linear function in Z-rotation (only for rz = NONLINEAR)
c_sys (Optional[CSys]) – coordinate system (default: LOCAL)
extent (Optional[Extent]) – extension of support (default: FULL)
c_def (Optional[CDef]) – coordinate definition (default: RELATIVE)
position_x1 (Optional[float]) – start of support along the edge with respect to origin ([m] if c_def = ABSOLUTE, else [-]) (default: 0.0)
position_x2 (Optional[float]) – end of support along the edge with respect to origin ([m] if c_def = ABSOLUTE, else [-]) (default: 1.0)
origin (Optional[Origin]) – reference for position_x1 and position_x2 (default: FROM_START)

Return type

LineSupportLine

create_line_support_on_plane(edge, *, name=None, x=None, stiffness_x=None, y=None, stiffness_y=None, z=None, stiffness_z=None, rx=None, stiffness_rx=None, ry=None, stiffness_ry=None, rz=None, stiffness_rz=None, c_sys=None, c_def=None, position_x1=None, position_x2=None, origin=None)¶

Method to construct a line support on a plane edge.

Parameters

edge (Union[Tuple[Plane, int], InternalEdge]) – tuple of the plane object (create_plane()) and edge number to which the load should be applied (1 = between plane.corner_nodes[0] and plane.corner_nodes[1], etc.), or InternalEdge (create_internal_edge())
name (Optional[str]) – name which will be shown in SCIA (default: ‘Sle{i}’)
x (Optional[Freedom]) – constraint type in X-direction (default: FREE)
stiffness_x (Optional[float]) – stiffness in X-direction [N/m2] (only for x = FLEXIBLE)
y (Optional[Freedom]) – constraint type in Y-direction (default: FREE)
stiffness_y (Optional[float]) – stiffness in Y-direction [N/m2] (only for y = FLEXIBLE)
z (Optional[Freedom]) – constraint type in Z-direction (default: FREE)
stiffness_z (Optional[float]) – stiffness in Z-direction [N/m2] (only for z = FLEXIBLE)
rx (Optional[Freedom]) – constraint type in X-rotation (default: FREE)
stiffness_rx (Optional[float]) – stiffness in X-rotation [Nm/m/rad] (only for rx = FLEXIBLE)
ry (Optional[Freedom]) – constraint type in Y-rotation (default: FREE)
stiffness_ry (Optional[float]) – stiffness in Y-rotation [Nm/m/rad] (only for ry = FLEXIBLE)
rz (Optional[Freedom]) – constraint type in Z-rotation (default: FREE)
stiffness_rz (Optional[float]) – stiffness in Z-rotation [Nm/m/rad] (only for rz = FLEXIBLE)
c_sys (Optional[CSys]) – coordinate system (default: GLOBAL)
c_def (Optional[CDef]) – coordinate definition (default: RELATIVE)
position_x1 (Optional[float]) – start of support along the edge with respect to origin ([m] if c_def = ABSOLUTE, else [-]) (default: 0.0)
position_x2 (Optional[float]) – end of support along the edge with respect to origin ([m] if c_def = ABSOLUTE, else [-]) (default: 1.0)
origin (Optional[Origin]) – reference for position_x1 and position_x2 (default: FROM_START)

Return type

LineSupportSurface

create_surface_support(plane, subsoil, *, name=None)¶

Method to construct a surface support.

Parameters

plane (Plane) – plane object (create_plane()) to which the support will be attached
subsoil (Subsoil) – subsoil object (create_subsoil()) representing the support
name (Optional[str]) – name which will be shown in SCIA

Return type

SurfaceSupportSurface

create_hinge_on_plane(edge, *, name=None, ux=None, stiffness_ux=None, uy=None, stiffness_uy=None, uz=None, stiffness_uz=None, fix=None, stiffness_fix=None, c_def=None, position_x1=None, position_x2=None, origin=None)¶

Method to construct a hinge on a plane edge.

Parameters

edge (Union[Tuple[Plane, int], InternalEdge]) – tuple of a plane object (create_plane()) and edge number to which the hinge will be attached (1 = between plane.corner_nodes[0] and plane.corner_nodes[1], etc.), or InternalEdge (create_internal_edge())
name (Optional[str]) – name which will be shown in SCIA (default: ‘L{i}’)
ux (Optional[Freedom]) – Freedom in ux (default: RIGID).
stiffness_ux (Optional[float]) – Stiffness in ux [N/m2], only used if freedom in ux = flexible (default: 0.0).
uy (Optional[Freedom]) – Freedom in uy (default: RIGID).
stiffness_uy (Optional[float]) – Stiffness in uy [N/m2], only used if freedom in uy = flexible (default: 0.0).
uz (Optional[Freedom]) – Freedom in uz (default: RIGID).
stiffness_uz (Optional[float]) – Stiffness in uz [N/m2], only used if freedom in uz = flexible (default: 0.0).
fix (Optional[Freedom]) – Freedom in fix (default: FREE).
stiffness_fix (Optional[float]) – Stiffness in fix [Nm/m/rad], only used if freedom in fix = flexible (default: 0.0).
c_def (Optional[CDef]) – coordinate definition (default: RELATIVE)
position_x1 (Optional[float]) – position of p1 along the edge with respect to origin ([m] if c_def = ABSOLUTE, else [-]) (default: 0.0)
position_x2 (Optional[float]) – position of p2 along the edge with respect to origin ([m] if c_def = ABSOLUTE, else [-]) (default: 1.0)
origin (Optional[Origin]) – reference for position_x1 and position_x2 (default: FROM_START)

Return type

HingeOnPlane

create_load_group(name, load_option, relation=None, load_type=None)¶

Method to construct a load group.

Parameters

name (str) – name which will be shown in SCIA
load_option (LoadOption) – enumeration of load option types
relation (Optional[RelationOption]) – enumeration of relation types
load_type (Optional[LoadTypeOption]) – enumeration of load types

Return type

LoadGroup

create_permanent_load_case(name, description, load_group, load_type, direction=None, primary_effect=None)¶

Method to construct a permanent load case.

Parameters

name (str) – name which will be shown in SCIA
description (str) – description which will be shown in SCIA
load_group (LoadGroup) – load group object (create_load_group()) in which the load case should be placed.
load_type (PermanentLoadType) – permanent load types
direction (Optional[Direction]) – load direction in case of a SELF_WEIGHT load type (default: NEG_Z)
primary_effect (Optional[LoadCase]) – previously created load case object in case the selected load type is PRIMARY_EFFECT

Return type

PermanentLoadCase

create_variable_load_case(name, description, load_group, load_type, specification=None, duration=None, primary_effect=None)¶

Method to construct a variable load case.

Parameters

name (str) – name which will be shown in SCIA
description (str) – description which will be shown in SCIA
load_group (LoadGroup) – load group object (create_load_group()) in which the load case should be placed.
load_type (VariableLoadType) – enumeration of variable load types
specification (Optional[Specification]) – enumeration of specification types
duration (Optional[Duration]) – enumeration of duration types
primary_effect (Optional[LoadCase]) – previously created load case object in case the selected load type is PRIMARY_EFFECT

Return type

VariableLoadCase

create_load_combination(name, load_type, load_cases, *, description=None)¶

Method to construct a load combination.

Parameters

name (str) – name which will be shown in SCIA
load_type (Type) – enumeration of load types
load_cases (Dict[LoadCase, float]) – dictionary of previously created load case object(s) with corresponding coefficient
description (Optional[str]) – description of the load combination
New in v13.1.0

Return type

LoadCombination

create_nonlinear_load_combination(load_type, load_cases, *, name=None, description=None)¶

Create a non-linear load combination.

Parameters

load_type (Type) – type of combination
load_cases (Dict[LoadCase, float]) – dictionary of previously created load case object(s) with corresponding coefficient
name (Optional[str]) – name which will be shown in SCIA (default: ‘NC{i}’)
description (Optional[str]) – description of the load combination
New in v13.1.0

Return type

NonLinearLoadCombination

create_result_class(name, combinations=None, nonlinear_combinations=None)¶

Method to construct a result class.

Parameters

name (str) – name which will be shown in SCIA
combinations (Optional[List[LoadCombination]]) – list of load combination objects (create_load_combination())
nonlinear_combinations (Optional[List[NonLinearLoadCombination]]) – list of nonlinear load combination objects (create_nonlinear_load_combination())

Return type

ResultClass

create_point_load_node(node, load_case, load, *, name=None, direction=None, c_sys=None, angle=None)¶

Method to construct a point load in a node.

Parameters

node (Node) – node object (create_node()) on which the load should be applied
load_case (LoadCase) – previously created load case object in which the load should be placed
load (float) – magnitude of the load in [N]
name (Optional[str]) – name which will be shown in SCIA (default: ‘F{i}’)
direction (Optional[Direction]) – direction of the load (default: Z)
c_sys (Optional[CSys]) – coordinate system (default: global)
angle (Optional[Tuple[float, float, float]]) – angle (Rx, Ry, Rz) [deg] of the load around the respective global X-, Y- and Z-axis

Return type

PointLoadNode

create_point_load(name, load_case, beam, direction, load_type, load_value, c_sys=None, c_def=None, position_x=None, origin=None, repeat=None, ey=None, ez=None, *, angle=None)¶

Method to construct a point load on a beam.

Parameters

name (str) – name which will be shown in SCIA
load_case (LoadCase) – previously created load case object in which the load should be placed
beam (Beam) – beam object (create_beam()) to which the load should be applied
direction (Direction) – enumeration of directions
load_type (Type) – enumeration of load types
load_value (float) – magnitude of the load in [N]
c_sys (Optional[CSys]) – enumeration of coordinate system types (default: global)
c_def (Optional[CDef]) – enumeration of coordinate definition types (default: relative)
position_x (Optional[float]) – position of the load (default: 0)
origin (Optional[Origin]) – enumeration of origin types (default: from start)
repeat (Optional[int]) – number of loads acting on the beam, distributed uniformly (default: 1)
ey (Optional[float]) – eccentricity in Y-direction w.r.t. the beam’s center line in [m] (default: 0)
ez (Optional[float]) – eccentricity in Z-direction w.r.t. the beam’s center line in [m] (default: 0)
angle (Optional[Tuple[float, float, float]]) – angle (Rx, Ry, Rz) [deg] of the load around the respective X-, Y- and Z-axis (default: 0)

Return type

PointLoad

create_point_moment_node(node, load_case, load, direction, name=None, c_sys=CSys.GLOBAL)¶

Create a point moment on an existing node.

Parameters

node (Node) – Node of appliance (create_node()).
load_case (LoadCase) – Previously created load case of appliance.
load (float) – Magnitude of the load [Nm].
direction (Direction) – Direction of the load.
name (Optional[str]) – Name of the load in SCIA (default: ‘M{i}’).
c_sys (CSys) – Coordinate system (default: global).

Return type

PointMomentNode

create_line_load(name, load_case, beam, load_type, distribution, load_start, load_end, direction, position_start, position_end, c_def, c_sys, origin, ey, ez)¶

Method to construct a line load on a beam.

Parameters

name (str) – name which will be shown in SCIA
load_case (LoadCase) – previously created load case object in which the load should be placed
beam (Beam) – beam object (create_beam()) to which the load should be applied
load_type (Type) – enumeration of load types
distribution (Distribution) – enumeration of distribution options
load_start (float) – magnitude of the load at the start point in [N]
load_end (float) – magnitude of the load at the end point in [N]
direction (Direction) – enumeration of directions
position_start (float) – position of the start point on the beam in [m]
position_end (float) – position of the end point on the beam in [m]
c_def (CDef) – enumeration of coordinate definition types
c_sys (CSys) – enumeration of coordinate system types
origin (Origin) – enumeration of origin types
ey (float) – eccentricity in Y-direction w.r.t. the beam’s center line in [m]
ez (float) – eccentricity in Z-direction w.r.t. the beam’s center line in [m]

Return type

LineLoad

create_line_moment_on_beam(beam, load_case, m1, m2=None, *, name=None, direction=None, c_def=None, position_x1=None, position_x2=None, origin=None)¶

Method to construct a line moment on a beam.

Parameters

beam (Beam) – beam object (create_beam()) to which the load should be applied
load_case (LoadCase) – previously created load case object in which the load should be applied
m1 (float) – magnitude of the moment [Nm/m] on point 1
m2 (Optional[float]) – magnitude of the moment [Nm/m] on point 2. None for uniform load (with magnitude m1) (default: None)
name (Optional[str]) – name which will be shown in SCIA (default: ‘LM{i}’)
direction (Optional[Direction]) – direction of the moment (default: Z)
c_def (Optional[CDef]) – coordinate definition (default: RELATIVE)
position_x1 (Optional[float]) – position of p1 along the beam with respect to origin ([m] if c_def = ABSOLUTE, else [-]) (default: 0.0)
position_x2 (Optional[float]) – position of p2 along the beam with respect to origin ([m] if c_def = ABSOLUTE, else [-]) (default: 1.0)
origin (Optional[Origin]) – reference for position_x1 and position_x2 (default: FROM_START)

Return type

LineMomentOnBeam

create_line_moment_on_plane(edge, m1, m2=None, *, load_case, name=None, direction=None, c_def=None, position_x1=None, position_x2=None, origin=None)¶

Method to construct a line moment on a plane edge.

Parameters

edge (Union[Tuple[Plane, int], InternalEdge]) – tuple of the plane object (create_plane()) and edge number to which the load should be applied (1 = between plane.corner_nodes[0] and plane.corner_nodes[1], etc.), or InternalEdge (create_internal_edge())
m1 (float) – magnitude of the moment [Nm/m] on point 1
m2 (Optional[float]) – magnitude of the moment [Nm/m] on point 2. None for uniform load (with magnitude m1) (default: None)
load_case (LoadCase) – previously created load case object in which the load should be applied
name (Optional[str]) – name which will be shown in SCIA (default: ‘LMS{i}’)
direction (Optional[Direction]) – direction of the moment (default: Z)
c_def (Optional[CDef]) – coordinate definition (default: RELATIVE)
position_x1 (Optional[float]) – position of p1 along the edge with respect to origin ([m] if c_def = ABSOLUTE, else [-]) (default: 0.0)
position_x2 (Optional[float]) – position of p2 along the edge with respect to origin ([m] if c_def = ABSOLUTE, else [-]) (default: 1.0)
origin (Optional[Origin]) – reference for position_x1 and position_x2 (default: FROM_START)

Return type

LineMomentOnPlane

create_line_load_on_plane(edge, p1, p2=None, *, load_case, direction=None, name=None, location=None, c_sys=None, c_def=None, position_x1=None, position_x2=None, origin=None)¶

Method to construct a line load on a plane edge.

Parameters

edge (Union[Tuple[Plane, int], InternalEdge]) – tuple of a plane object (create_plane()) and edge number to which the load will be applied (1 = between plane.corner_nodes[0] and plane.corner_nodes[1], etc.), or InternalEdge (create_internal_edge())
p1 (float) – magnitude of the load [N/m] on point 1
p2 (Optional[float]) – magnitude of the load [N/m] on point 2. None for uniform load (with magnitude p1) (default: None)
load_case (LoadCase) – previously created load case object in which the load should be applied
direction (Optional[Direction]) – direction of the load (default: Z)
name (Optional[str]) – name which will be shown in SCIA (default: ‘LFS{i}’)
location (Optional[Location]) – location type (default: LENGTH)
c_sys (Optional[CSys]) – coordinate system (default: LOCAL)
c_def (Optional[CDef]) – coordinate definition (default: RELATIVE)
position_x1 (Optional[float]) – position of p1 along the edge with respect to origin ([m] if c_def = ABSOLUTE, else [-]) (default: 0.0)
position_x2 (Optional[float]) – position of p2 along the edge with respect to origin ([m] if c_def = ABSOLUTE, else [-]) (default: 1.0)
origin (Optional[Origin]) – reference for position_x1 and position_x2 (default: FROM_START)

Return type

LineForceSurface

create_surface_load(name, load_case, plane, direction, load_type, load_value, c_sys, location)¶

Method to construct a surface load on a plane.

Parameters

name (str) – name which will be shown in SCIA
load_case (LoadCase) – previously created load case object in which the load should be placed
plane (Plane) – plane object (create_plane()) to which the load should be applied
direction (Direction) – enumeration of directions
load_type (Type) – enumeration of load types
load_value (float) – magnitude of the load in [N]
c_sys (CSys) – enumeration of coordinate system types
location (Location) – enumeration of location options

Return type

SurfaceLoad

create_thermal_load(name, load_case, beam, distribution, delta, left_delta, right_delta, top_delta, bottom_delta, position_start, position_end, c_def, origin)¶

Method to construct a temperature load on a beam.

Parameters

name (str) – name which will be shown in SCIA
load_case (LoadCase) – previously created load case object in which the load should be placed
beam (Beam) – beam object (create_beam()) to which the load should be applied
distribution (Distribution) – enumeration of distribution options
delta (float) – temperature difference in case of a CONSTANT distribution
left_delta (float) – temperature difference in +Y direction
right_delta (float) – temperature difference in -Y direction
top_delta (float) – temperature difference in +Z direction
bottom_delta (float) – temperature difference in -Z direction
position_start (float) – position of the start point on the beam in [m]
position_end (float) – position of the end point on the beam in [m]
c_def (CDef) – enumeration of coordinate definition types
origin (Origin) – enumeration of origin types

Return type

ThermalLoad

create_thermal_surface_load(name, load_case, plane, delta=None, top_delta=None, bottom_delta=None)¶

Method to construct a temperature load on a plane.

Parameters

name (str) – name which will be shown in SCIA
load_case (LoadCase) – previously created load case object in which the load should be placed
plane (Plane) – plane object (create_plane()) to which the load should be applied
delta (Optional[float]) – temperature difference in case of a constant distribution
top_delta (Optional[float]) – temperature difference in +Z direction
bottom_delta (Optional[float]) – temperature difference in -Z direction

Return type

ThermalSurfaceLoad

create_free_surface_load(name, load_case, direction, q1, q2=None, q3=None, points=None, *, distribution=None, selection=None)¶

Method to construct a free surface load.

Note: can only be defined in XY-plane.

Parameters

name (str) – name which will be shown in SCIA
load_case (LoadCase) – previously created load case object in which the load should be placed
direction (Direction) – direction of the load
q1 (float) – magnitude of the load in the first point in [N]
q2 (Optional[float]) – magnitude of the load in the second point in [N] (distribution = DIR_X | DIR_Y | POINTS only)
q3 (Optional[float]) – magnitude of the load in the third point in [N] (distribution = POINTS only)
points (Optional[List[Tuple[float, float]]]) – list of XY coordinates (at least 3). If distribution = DIR_X | DIR_Y: q1 and q2 are applied to points[0] and points[1] respectively. If distribution = POINTS: q1, q2 and q3 are applied to points[0], points[1] and points[2] respectively.
distribution (Optional[Distribution]) – distribution of the load (default: POINTS)
selection (Optional[List[Plane]]) – selection of 1 or more planes (create_plane()) to generate the load on (default: select = auto)

Return type

FreeSurfaceLoad

create_free_line_load(name, load_case, point_1, point_2, direction, magnitude_1, magnitude_2)¶

Method to construct a free line load.

Parameters

name (str) – name which will be shown in SCIA
load_case (LoadCase) – previously created load case object in which the load should be placed
point_1 (Tuple[float, float]) – XY coordinate of the first point
point_2 (Tuple[float, float]) – XY coordinate of the second point
direction (Direction) – enumeration of direction options
magnitude_1 (float) – magnitude of the load in point_1 in [N]
magnitude_2 (float) – magnitude of the load in point_2 in [N]

Return type

FreeLineLoad

create_free_point_load(name, load_case, direction, magnitude, position)¶

Method to construct a free point load.

Parameters

name (str) – name which will be shown in SCIA
load_case (LoadCase) – previously created load case object in which the load should be placed
direction (Direction) – enumeration of direction options
magnitude (float) – magnitude of the load in [N]
position (Tuple[float, float]) – XY coordinate of the load

Return type

FreePointLoad

generate_xml_input(as_file=False)¶

Returns the input file XML representation of the SCIA model and corresponding .def file.

Note

This method needs to be mocked in (automated) unit and integration tests.

Return type

Union[Tuple[BytesIO, BytesIO], Tuple[File, File]]

Returns

File if as_file = True
BytesIO if as_file = False (default)

OutputFileParser

class viktor.external.scia.scia.OutputFileParser¶

Helper class to extract results from a SCIA output file (.xml).

Example using BytesIO:

xml_output_file = scia_analysis.get_xml_output_file()
result_table = OutputFileParser.get_result(xml_output_file, 'Reactions')
another_result_table = OutputFileParser.get_result(xml_output_file, '2D internal forces')

Example using File:

xml_output_file = scia_analysis.get_xml_output_file(as_file=True)
with xml_output_file.open_binary() as f:
    result_table = OutputFileParser.get_result(f, 'Reactions')
    another_result_table = OutputFileParser.get_result(f, '2D internal forces')

classmethod get_result(file, table_name, *, parent=None)¶

Retrieve the results of an output XML by ‘table_name’. This corresponds to the ‘name’ attribute that is found in the XML table, e.g. “Result classes - UGT” in the example below:

<container id="..." t="...">
    <table id="..." t="..." name="Result classes - UGT">

In case indenting has been used in the SCIA I/O doc, multiple tables with the name ‘table_name’ will be found. A parent name can be specified as input to account for this indenting (up to 1 indent level). If indenting is used but no parent name is specified, this method will return the first ‘table_name’ table it can find.

Parameters

file (BinaryIO) – SCIA output file (.xml).
table_name (str) – Name of the result table to be extracted from the output XML.
parent (Optional[str]) – Name of the parent, e.g. a result class.

:raises viktor.errors.SciaParsingError:

if table ‘table_name’ could not be found in the provided output file
if no results were found in the XML table ‘table_name’

Return type: Dict[str, dict]

Layer

class viktor.external.scia.object.Layer(object_id, name, comment=None, structural_model_only=None, current_used_activity=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_layer()

Material

class viktor.external.scia.object.Material(object_id, name)¶

Bases: _SciaObject

Reference to an existing material in the .esa template file in which the xml input file will be loaded.

Parameters

object_id (int) – ID of the existing material.
name (str) – name of the existing material.

NonLinearFunction

class viktor.external.scia.object.NonLinearFunction(object_id, name, function_type, positive_end, negative_end, impulse)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_nonlinear_function()

class Type(value)¶

Bases: Enum

An enumeration.

TRANSLATION: Type = 0¶

ROTATION: Type = 1¶

NONLINEAR_SUBSOIL: Type = 2¶

class Support(value)¶

Bases: Enum

An enumeration.

RIGID: Support = 0¶

FREE: Support = 1¶

FLEXIBLE: Support = 2¶

property impulse: List[Tuple[float, float]]¶

Return type: List[Tuple[float, float]]

Subsoil

class viktor.external.scia.object.Subsoil(object_id, name, stiffness, c1x=None, c1y=None, c1z=None, nonlinear_function=None, c2x=None, c2y=None, is_drained=None, water_air_in_clay_subgrade=None, specific_weight=None, fi=None, sigma_oc=None, c=None, cu=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_subsoil()

class C1z(value)¶

Bases: Enum

An enumeration.

FLEXIBLE: C1z = 0¶

NONLINEAR_FUNCTION: C1z = 1¶

property nonlinear_function: Optional[NonLinearFunction]¶

Return type: Optional[NonLinearFunction]

Orthotropy

class viktor.external.scia.object.Orthotropy(object_id, name, material, thickness, D11=None, D22=None, D12=None, D33=None, D44=None, D55=None, d11=None, d22=None, d12=None, d33=None, kxy=None, kyx=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_orthotropy()

CrossSection

class viktor.external.scia.object.CrossSection(object_id, name, material)¶

Bases: _SciaObject, ABC

Abstract base class of all cross sections.

RectangularCrossSection

class viktor.external.scia.object.RectangularCrossSection(object_id, name, material, width, height)¶

Bases: CrossSection

Do not use this __init__ directly, but create the object by create_rectangular_cross_section()

CircularCrossSection

class viktor.external.scia.object.CircularCrossSection(object_id, name, material, diameter)¶

Bases: CrossSection

Do not use this __init__ directly, but create the object by create_circular_cross_section()

CircularHollowCrossSection

class viktor.external.scia.object.CircularHollowCrossSection(object_id, name, material, diameter, thickness)¶

Bases: CrossSection

Do not use this __init__ directly, but create the object by create_circular_hollow_cross_section()

ComposedCrossSection

class viktor.external.scia.object.ComposedCrossSection(object_id, name, material, material_2)¶

Bases: CrossSection, ABC

Abstract base class of all cross sections, composed of two materials.

CircularComposedCrossSection

class viktor.external.scia.object.CircularComposedCrossSection(object_id, name, material, material_2, diameter, thickness)¶

Bases: ComposedCrossSection

Do not use this __init__ directly, but create the object by create_circular_composed_cross_section()

NumericalCrossSection

class viktor.external.scia.object.NumericalCrossSection(object_id, name, material, *, A=None, Ay=None, Az=None, AL=None, AD=None, cYUCS=None, cZUCS=None, alpha=None, Iy=None, Iz=None, Wely=None, Welz=None, Wply=None, Wplz=None, Mply_plus=None, Mply_min=None, Mplz_plus=None, Mplz_min=None, dy=None, dz=None, It=None, Iw=None, beta_y=None, beta_z=None)¶

Bases: CrossSection

Do not use this __init__ directly, but create the object by create_numerical_cross_section()

LibraryCrossSection

class viktor.external.scia.object.LibraryCrossSection(object_id, name, material, section, profile)¶

Bases: CrossSection

Do not use this __init__ directly, but create the object by create_library_cross_section()

class Section(value)¶

Bases: Enum

An enumeration.

I: Section = 1¶

RECTANGULAR_HOLLOW: Section = 2¶

CIRCULAR_HOLLOW: Section = 3¶

L: Section = 4¶

CHANNEL: Section = 5¶

T: Section = 6¶

FULL_RECTANGULAR: Section = 7¶

FULL_CIRCULAR: Section = 11¶

ASYMMETRIC_I: Section = 101¶

ROLLED_Z: Section = 102¶

GENERAL_COLD_FORMED: Section = 110¶

COLD_FORMED_ANGLE: Section = 111¶

COLD_FORMED_CHANNEL: Section = 112¶

COLD_FORMED_Z: Section = 113¶

COLD_FORMED_C: Section = 114¶

COLD_FORMED_OMEGA: Section = 115¶

COLD_FORMED_C_EAVES_BEAM: Section = 116¶

COLD_FORMED_C_PLUS: Section = 117¶

COLD_FORMED_ZED: Section = 118¶

COLD_FORMED_ZED_ASYMMETRIC_LIPS: Section = 119¶

COLD_FORMED_ZED_INCLINED_LIP: Section = 120¶

COLD_FORMED_SIGMA: Section = 121¶

COLD_FORMED_SIGMA_STIFFENED: Section = 122¶

COLD_FORMED_SIGMA_PLUS: Section = 123¶

COLD_FORMED_SIGMA_EAVES_BEAM: Section = 124¶

COLD_FORMED_SIGMA_PLUS_EAVES_BEAM: Section = 125¶

COLD_FORMED_ZED_BOTH_LIPS_INCLINED: Section = 126¶

COLD_FORMED_I_PLUS: Section = 127¶

COLD_FORMED_IS_PLUS: Section = 128¶

COLD_FORMED_SIGMA_ASYMMETRIC: Section = 129¶

COLD_FORMED_2C: Section = 130¶

RAIL_TYPE_KA: Section = 150¶

RAIL_TYPE_KF: Section = 151¶

RAIL_TYPE_KG: Section = 152¶

SFB: Section = 153¶

IFBA: Section = 154¶

IFBB: Section = 155¶

THQ: Section = 156¶

VIRTUAL_JOIST: Section = 160¶

MINUS_L: Section = 1002¶

Node

class viktor.external.scia.object.Node(object_id, name, x, y, z)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_node()

Beam

class viktor.external.scia.object.Beam(object_id, name, begin_node, end_node, cross_section, ez=None, lcs_rotation=None, layer=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_beam()

property begin_node: Node¶

Return type: Node

property end_node: Node¶

Return type: Node

property cross_section: CrossSection¶

Return type: CrossSection

property ez: float¶

Return type: float

CrossLink

class viktor.external.scia.object.CrossLink(object_id, name, beam_1, beam_2)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_cross_link()

ArbitraryProfileSpan

class viktor.external.scia.object.ArbitraryProfileSpan(length, type_of_css, cross_section_start, cross_section_end, alignment)¶

Do not use this __init__ directly, but create the object by create_arbitrary_profile_span()

class TypeOfCss(value)¶

Bases: Enum

PRISMATIC - The cross-section of the span is constant.
PARAM_HAUNCH - A standard haunch is inserted into the span.
TWO_CSS - Two cross-sections corresponding to the two end-points of the span are defined. The cross-section varies over the span from one section to the other.

PRISMATIC: TypeOfCss = 0¶

PARAM_HAUNCH: TypeOfCss = 1¶

TWO_CSS: TypeOfCss = 2¶

class Alignment(value)¶

Bases: Enum

DEFAULT - see “Default” at https://help.scia.net/18.1/en/rb/modelling/haunch_beam.htm#Haunch_Alignment
CENTER_LINE - see “Centre line” at https://help.scia.net/18.1/en/rb/modelling/haunch_beam.htm#Haunch_Alignment
TOP_SURFACE - see “Top surface” at https://help.scia.net/18.1/en/rb/modelling/haunch_beam.htm#Haunch_Alignment
BOTTOM_SURFACE - see “Bottom surface” at https://help.scia.net/18.1/en/rb/modelling/haunch_beam.htm#Haunch_Alignment
LEFT_SURFACE - see “Left surface” at https://help.scia.net/18.1/en/rb/modelling/haunch_beam.htm#Haunch_Alignment
RIGHT_SURFACE - see “Right surface” at https://help.scia.net/18.1/en/rb/modelling/haunch_beam.htm#Haunch_Alignment
TOP_LEFT -
TOP_RIGHT -
BOTTOM_LEFT -
BOTTOM_RIGHT -

DEFAULT: Alignment = 0¶

CENTER_LINE: Alignment = 1¶

TOP_SURFACE: Alignment = 2¶

BOTTOM_SURFACE: Alignment = 3¶

LEFT_SURFACE: Alignment = 4¶

RIGHT_SURFACE: Alignment = 5¶

TOP_LEFT: Alignment = 6¶

TOP_RIGHT: Alignment = 7¶

BOTTOM_LEFT: Alignment = 8¶

BOTTOM_RIGHT: Alignment = 9¶

property cross_section_start: CrossSection¶

Return type: CrossSection

property cross_section_end: CrossSection¶

Return type: CrossSection

ArbitraryProfile

class viktor.external.scia.object.ArbitraryProfile(object_id, name, beam, c_def, cross_section, spans)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_arbitrary_profile()

class CDef(value)¶

Bases: Enum

ABSOLUTE - absolute
RELATIVE - relative

ABSOLUTE: CDef = 0¶

RELATIVE: CDef = 1¶

property beam: Beam¶

Return type: Beam

property cross_section: CrossSection¶

Return type: CrossSection

property spans: List[ArbitraryProfileSpan]¶

Return type: List[ArbitraryProfileSpan]

HingeOnBeam

class viktor.external.scia.object.HingeOnBeam(object_id, name, beam, position, freedom_ux=Freedom.FREE, freedom_uy=Freedom.FREE, freedom_uz=Freedom.FREE, freedom_fix=Freedom.FREE, freedom_fiy=Freedom.FREE, freedom_fiz=Freedom.FREE, stiffness_ux=0, stiffness_uy=0, stiffness_uz=0, stiffness_fix=0, stiffness_fiy=0, stiffness_fiz=0)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_hinge_on_beam().

class Position(value)¶

Bases: Enum

An enumeration.

BEGIN: Position = 0¶

END: Position = 1¶

BOTH: Position = 2¶

class Freedom(value)¶

Bases: Enum

FREE - The support is free in the specified direction. That is it imposes no constraint in the direction.
RIGID - The support in fully rigid in the specified direction.
FLEXIBLE - The support is flexible (elastic) in the specified direction. The user has to define the required stiffness of the support.

FREE: Freedom = 0¶

RIGID: Freedom = 1¶

FLEXIBLE: Freedom = 2¶

property beam: Beam¶

Return type: Beam

property freedom: Tuple[Freedom, Freedom, Freedom, Freedom, Freedom, Freedom]¶

ux, uy, uz, fix, fiy, fiz

Return type: Tuple[Freedom, Freedom, Freedom, Freedom, Freedom, Freedom]

property stiffness: Tuple[float, float, float, float, float, float]¶

ux, uy, uz, fix, fiy, fiz

Return type: Tuple[float, float, float, float, float, float]

HingeOnPlane

class viktor.external.scia.object.HingeOnPlane(object_id, name, edge, ux=None, stiffness_ux=None, uy=None, stiffness_uy=None, uz=None, stiffness_uz=None, fix=None, stiffness_fix=None, c_def=None, position_x1=None, position_x2=None, origin=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_hinge_on_plane().

class CDef(value)¶

Bases: Enum

ABSOLUTE - absolute, where the coordinate must lie between 0 and the length of the plane edge
RELATIVE - relative, where the coordinate must lie between 0 and 1

ABSOLUTE: CDef = 0¶

RELATIVE: CDef = 1¶

class Freedom(value)¶

Bases: Enum

FREE - The support is free in the specified direction. That is it imposes no constraint in the direction.
RIGID - The support in fully rigid in the specified direction.
FLEXIBLE - The support is flexible (elastic) in the specified direction. The user has to define the required stiffness of the support.

FREE: Freedom = 0¶

RIGID: Freedom = 1¶

FLEXIBLE: Freedom = 2¶

class Origin(value)¶

Bases: Enum

FROM_START - position is measured from the beginning of the plane edge
FROM_END - position is measured from the end of the plane edge

FROM_START: Origin = 0¶

FROM_END: Origin = 1¶

property plane: Plane¶

Return type: Plane

Plane

class viktor.external.scia.object.Plane(object_id, name, thickness, material, *, plane_type=None, layer=None, corner_nodes=None, internal_nodes=None, swap_orientation=None, lcs_rotation=None, fem_model=None, orthotropy=None, center_node=None, vertex_node=None, axis=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_plane() or create_circular_plane()

class FEMModel(value)¶

Bases: Enum

An enumeration.

ISOTROPIC: FEMModel = 0¶

ORTHOTROPIC: FEMModel = 1¶

class Type(value)¶

Bases: Enum

PLATE - A standard plate is a planar 2D member with an arbitrary number of edges that may be straight or curved.
WALL - A wall is a vertical 2D member whose base is either straight or curved.
SHELL - Shells are defined by border lines (i.e. border curves). The shape of the shell can be defined by four, three or two curves / straight lines.

PLATE: Type = 0¶

WALL: Type = 1¶

SHELL: Type = 2¶

property corner_nodes: List[Node]¶

Return type: List[Node]

property internal_nodes: List[Node]¶

Return type: List[Node]

property swap_orientation: bool¶

Return type: bool

property lcs_rotation: float¶

Return type: float

LineSupport

class viktor.external.scia.object.LineSupport(object_id, name, x=None, stiffness_x=None, function_x=None, y=None, stiffness_y=None, function_y=None, z=None, stiffness_z=None, function_z=None, rx=None, stiffness_rx=None, function_rx=None, ry=None, stiffness_ry=None, function_ry=None, rz=None, stiffness_rz=None, function_rz=None, c_sys=None, c_def=None, position_x1=None, position_x2=None, origin=None)¶

Bases: _SciaObject, ABC

Abstract base class of all line supports.

class Constraint(value)¶

Bases: Enum

An enumeration.

FIXED: Constraint = 0¶

HINGED: Constraint = 1¶

SLIDING: Constraint = 2¶

CUSTOM: Constraint = 3¶

class Type(value)¶

Bases: Enum

An enumeration.

LINE: Type = 0¶

FOUNDATION_STRIP: Type = 1¶

WALL: Type = 2¶

class Freedom(value)¶

Bases: Enum

An enumeration.

FREE: Freedom = 0¶

RIGID: Freedom = 1¶

FLEXIBLE: Freedom = 2¶

RIGID_PRESS_ONLY: Freedom = 3¶

RIGID_TENSION_ONLY: Freedom = 4¶

FLEXIBLE_PRESS_ONLY: Freedom = 5¶

FLEXIBLE_TENSION_ONLY: Freedom = 6¶

NONLINEAR: Freedom = 7¶

class CSys(value)¶

Bases: Enum

An enumeration.

GLOBAL: CSys = 0¶

LOCAL: CSys = 1¶

class CDef(value)¶

Bases: Enum

ABSOLUTE - absolute, where the coordinate must lie between 0 and the length of the beam
RELATIVE - relative, where the coordinate must lie between 0 and 1

ABSOLUTE: CDef = 0¶

RELATIVE: CDef = 1¶

class Extent(value)¶

Bases: Enum

FULL - support across the full length
SPAN - support across a span

FULL: Extent = 0¶

SPAN: Extent = 1¶

class Origin(value)¶

Bases: Enum

FROM_START - position is measured from the beginning of the beam
FROM_END - position is measured from the end of the beam

FROM_START: Origin = 0¶

FROM_END: Origin = 1¶

property constraint: Constraint¶

Return type: Constraint

property freedom: Tuple[Freedom, Freedom, Freedom, Freedom, Freedom, Freedom]¶

Return type: Tuple[Freedom, Freedom, Freedom, Freedom, Freedom, Freedom]

property stiffness: Tuple[Optional[float], Optional[float], Optional[float], Optional[float], Optional[float], Optional[float]]¶

Return type: Tuple[Optional[float], Optional[float], Optional[float], Optional[float], Optional[float], Optional[float]]

property function_x: Optional[NonLinearFunction]¶

Return type: Optional[NonLinearFunction]

property function_y: Optional[NonLinearFunction]¶

Return type: Optional[NonLinearFunction]

property function_z: Optional[NonLinearFunction]¶

Return type: Optional[NonLinearFunction]

property function_rx: Optional[NonLinearFunction]¶

Return type: Optional[NonLinearFunction]

property function_ry: Optional[NonLinearFunction]¶

Return type: Optional[NonLinearFunction]

property function_rz: Optional[NonLinearFunction]¶

Return type: Optional[NonLinearFunction]

LineSupportLine

class viktor.external.scia.object.LineSupportLine(object_id, name, beam, x=None, stiffness_x=None, function_x=None, y=None, stiffness_y=None, function_y=None, z=None, stiffness_z=None, function_z=None, rx=None, stiffness_rx=None, function_rx=None, ry=None, stiffness_ry=None, function_ry=None, rz=None, stiffness_rz=None, function_rz=None, c_sys=None, extent=None, c_def=None, position_x1=None, position_x2=None, origin=None)¶

Bases: LineSupport

Do not use this __init__ directly, but create the object by create_line_support_on_beam()

property beam: Beam¶

Return type: Beam

property spring_type: Type¶

Return type: Type

LineSupportSurface

class viktor.external.scia.object.LineSupportSurface(object_id, name, edge, x=None, stiffness_x=None, y=None, stiffness_y=None, z=None, stiffness_z=None, rx=None, stiffness_rx=None, ry=None, stiffness_ry=None, rz=None, stiffness_rz=None, c_sys=None, c_def=None, position_x1=None, position_x2=None, origin=None)¶

Bases: LineSupport

Do not use this __init__ directly, but create the object by create_line_support_on_plane()

property plane: Plane¶

Return type: Plane

SurfaceSupportSurface

class viktor.external.scia.object.SurfaceSupportSurface(object_id, name, plane, subsoil)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_surface_support()

property plane: Plane¶

Return type: Plane

property subsoil: Subsoil¶

Return type: Subsoil

OpenSlab

class viktor.external.scia.object.OpenSlab(object_id, name, plane, corner_nodes)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_open_slab()

property plane: Plane¶

Return type: Plane

property corner_nodes: List[Node]¶

Return type: List[Node]

InternalEdge

class viktor.external.scia.object.InternalEdge(object_id, name, plane, node_1, node_2)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_internal_edge()

property plane: Plane¶

Return type: Plane

property node_1: Node¶

Return type: Node

property node_2: Node¶

Return type: Node

PointSupport

class viktor.external.scia.object.PointSupport(object_id, name, node, spring_type, freedom, stiffness, c_sys, default_size=0.2, angle=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_point_support()

class Constraint(value)¶

Bases: Enum

An enumeration.

FIXED: Constraint = 0¶

HINGED: Constraint = 1¶

SLIDING: Constraint = 2¶

CUSTOM: Constraint = 3¶

class Type(value)¶

Bases: Enum

An enumeration.

STANDARD: Type = 0¶

PAD_FOUNDATION: Type = 1¶

COLUMN: Type = 2¶

class Freedom(value)¶

Bases: Enum

FREE - The support is free in the specified direction. That is it imposes no constraint in the direction.
RIGID - The support in fully rigid in the specified direction.
FLEXIBLE - The support is flexible (elastic) in the specified direction. The user has to define the required stiffness of the support.

FREE: Freedom = 0¶

RIGID: Freedom = 1¶

FLEXIBLE: Freedom = 2¶

class CSys(value)¶

Bases: Enum

An enumeration.

GLOBAL: CSys = 0¶

LOCAL: CSys = 1¶

property node: Node¶

Return type: Node

property constraint: Constraint¶

Return type: Constraint

PointSupportLine

class viktor.external.scia.object.PointSupportLine(object_id, name, beam, x=None, stiffness_x=None, y=None, stiffness_y=None, z=None, stiffness_z=None, rx=None, stiffness_rx=None, ry=None, stiffness_ry=None, rz=None, stiffness_rz=None, default_size=None, c_sys=None, c_def=None, position_x=None, origin=None, repeat=None, delta_x=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_point_support_on_beam()

class Freedom(value)¶

Bases: Enum

FREE - The support is free in the specified direction. That is it imposes no constraint in the direction.
RIGID - The support in fully rigid in the specified direction.
FLEXIBLE - The support is flexible (elastic) in the specified direction. The user has to define the required stiffness of the support.

FREE: Freedom = 0¶

RIGID: Freedom = 1¶

FLEXIBLE: Freedom = 2¶

class CSys(value)¶

Bases: Enum

An enumeration.

GLOBAL: CSys = 0¶

LOCAL: CSys = 1¶

class CDef(value)¶

Bases: Enum

ABSOLUTE - absolute, where the coordinate must lie between 0 and the length of the beam
RELATIVE - relative, where the coordinate must lie between 0 and 1

ABSOLUTE: CDef = 0¶

RELATIVE: CDef = 1¶

class Origin(value)¶

Bases: Enum

FROM_START - position is measured from the beginning of the beam
FROM_END - position is measured from the end of the beam

FROM_START: Origin = 0¶

FROM_END: Origin = 1¶

RigidArm

class viktor.external.scia.object.RigidArm(object_id, name, master_node, slave_node, hinge_on_master, hinge_on_slave)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_rigid_arm()

property master_node: Node¶

Return type: Node

property slave_node: Node¶

Return type: Node

SectionOnBeam

class viktor.external.scia.object.SectionOnBeam(object_id, name, beam, c_def, position_x, origin, repeat, delta_x)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_section_on_beam()

class CDef(value)¶

Bases: Enum

ABSOLUTE - absolute, where the coordinate must lie between 0 and the length of the beam
RELATIVE - relative, where the coordinate must lie between 0 and 1

ABSOLUTE: CDef = 0¶

RELATIVE: CDef = 1¶

class Origin(value)¶

Bases: Enum

FROM_START - position is measured from the beginning of the beam
FROM_END - position is measured from the end of the beam

FROM_START: Origin = 0¶

FROM_END: Origin = 1¶

property beam: Beam¶

Return type: Beam

LoadGroup

class viktor.external.scia.object.LoadGroup(object_id, name, load_option, relation=None, load_type=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_load_group()

class LoadOption(value)¶

Bases: Enum

An enumeration.

PERMANENT: LoadOption = 0¶

VARIABLE: LoadOption = 1¶

ACCIDENTAL: LoadOption = 2¶

SEISMIC: LoadOption = 3¶

class RelationOption(value)¶

Bases: Enum

An enumeration.

STANDARD: RelationOption = 0¶

EXCLUSIVE: RelationOption = 1¶

TOGETHER: RelationOption = 2¶

class LoadTypeOption(value)¶

Bases: Enum

CAT_A - Domestic
CAT_B - Offices
CAT_C - Congregation
CAT_D - Shopping
CAT_E - Storage
CAT_F - Vehicle <30kN
CAT_G - Vehicle >30kN
CAT_H - Roofs
SNOW - Snow
WIND - Wind
TEMPERATURE - Temperature
RAIN_WATER - Rain water
CONSTRUCTION_LOADS - Construction loads

CAT_A: LoadTypeOption = 0¶

CAT_B: LoadTypeOption = 1¶

CAT_C: LoadTypeOption = 2¶

CAT_D: LoadTypeOption = 3¶

CAT_E: LoadTypeOption = 4¶

CAT_F: LoadTypeOption = 5¶

CAT_G: LoadTypeOption = 6¶

CAT_H: LoadTypeOption = 7¶

SNOW: LoadTypeOption = 8¶

WIND: LoadTypeOption = 11¶

TEMPERATURE: LoadTypeOption = 12¶

RAIN_WATER: LoadTypeOption = 20¶

CONSTRUCTION_LOADS: LoadTypeOption = 21¶

property relation: Optional[RelationOption]¶

Return type: Optional[RelationOption]

property load_type: Optional[LoadTypeOption]¶

Return type: Optional[LoadTypeOption]

LoadCase

class viktor.external.scia.object.LoadCase(object_id, name, description, action_type, load_group)¶

Bases: ABC, _SciaObject

Abstract base class of all load cases.

class ActionType(value)¶

Bases: Enum

An enumeration.

PERMANENT: ActionType = 0¶

VARIABLE: ActionType = 1¶

class PermanentLoadType(value)¶

Bases: Enum

An enumeration.

SELF_WEIGHT: PermanentLoadType = 0¶

STANDARD: PermanentLoadType = 1¶

PRIMARY_EFFECT: PermanentLoadType = 2¶

class VariableLoadType(value)¶

Bases: Enum

An enumeration.

STATIC: VariableLoadType = 0¶

PRIMARY_EFFECT: VariableLoadType = 1¶

class Specification(value)¶

Bases: Enum

An enumeration.

STANDARD: Specification = 100¶

TEMPERATURE: Specification = 101¶

STATIC_WIND: Specification = 102¶

EARTHQUAKE: Specification = 103¶

SNOW: Specification = 104¶

class Duration(value)¶

Bases: Enum

An enumeration.

LONG: Duration = 0¶

MEDIUM: Duration = 1¶

SHORT: Duration = 2¶

INSTANTANEOUS: Duration = 3¶

class Direction(value)¶

Bases: Enum

NEG_Z - -Z
POS_Z - +Z
NEG_Y - -Y
POS_Y - +Y
NEG_X - -X
POS_X - +X

NEG_Z: Direction = 0¶

POS_Z: Direction = 1¶

NEG_Y: Direction = 2¶

POS_Y: Direction = 3¶

NEG_X: Direction = 4¶

POS_X: Direction = 5¶

property load_group: LoadGroup¶

Return type: LoadGroup

abstract property load_type: Union[PermanentLoadType, VariableLoadType]¶

Return type: Union[PermanentLoadType, VariableLoadType]

abstract property direction: Optional[Direction]¶

Return type: Optional[Direction]

abstract property specification: Optional[Specification]¶

Return type: Optional[Specification]

abstract property duration: Optional[Duration]¶

Return type: Optional[Duration]

abstract property master: Optional[str]¶

Return type: Optional[str]

abstract property primary_effect: Optional[LoadCase]¶

Return type: Optional[LoadCase]

PermanentLoadCase

class viktor.external.scia.object.PermanentLoadCase(object_id, name, description, load_group, load_type, direction=None, primary_effect=None)¶

Bases: LoadCase

Do not use this __init__ directly, but create the object by create_permanent_load_case()

property load_type: PermanentLoadType¶

Return type: PermanentLoadType

property direction: Optional[Direction]¶

Return type: Optional[Direction]

property specification: None¶

Return type: None

property duration: None¶

Return type: None

property master: None¶

Return type: None

property primary_effect: Optional[LoadCase]¶

Return type: Optional[LoadCase]

VariableLoadCase

class viktor.external.scia.object.VariableLoadCase(object_id, name, description, load_group, load_type, specification=None, duration=None, primary_effect=None, master=None)¶

Bases: LoadCase

Do not use this __init__ directly, but create the object by create_variable_load_case()

property load_type: VariableLoadType¶

Return type: VariableLoadType

property master: Optional[str]¶

Return type: Optional[str]

property specification: Optional[Specification]¶

Return type: Optional[Specification]

property duration: Optional[Duration]¶

Return type: Optional[Duration]

property direction: None¶

Return type: None

property primary_effect: Optional[LoadCase]¶

Return type: Optional[LoadCase]

LoadCombination

class viktor.external.scia.object.LoadCombination(object_id, name, combination_type, load_cases, *, description=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_load_combination()

class Type(value)¶

Bases: Enum

ENVELOPE_ULTIMATE - Envelope - ultimate
ENVELOPE_SERVICEABILITY - Envelope - serviceability
LINEAR_ULTIMATE - Linear - ultimate
LINEAR_SERVICEABILITY - Linear - serviceability
EN_ULS_SET_B - EN-ULS (STR/GEO) Set B
EN_ACC_ONE - EN-Accidental 1
EN_ACC_TWO - EN-Accidental 2
EN_SEISMIC - EN-Seismic
EN_SLS_CHAR - EN-SLS Characteristic
EN_SLS_FREQ - EN-SLS Frequent
EN_SLS_QUASI - EN-SLS Quasi-permanent
EN_ULS_SET_C - EN-ULS (STR/GEO) Set C

ENVELOPE_ULTIMATE: Type = 0¶

ENVELOPE_SERVICEABILITY: Type = 1¶

LINEAR_ULTIMATE: Type = 2¶

LINEAR_SERVICEABILITY: Type = 3¶

EN_ULS_SET_B: Type = 4¶

EN_ACC_ONE: Type = 5¶

EN_ACC_TWO: Type = 6¶

EN_SEISMIC: Type = 7¶

EN_SLS_CHAR: Type = 8¶

EN_SLS_FREQ: Type = 9¶

EN_SLS_QUASI: Type = 10¶

EN_ULS_SET_C: Type = 11¶

property load_cases: Dict[LoadCase, float]¶

Return type: Dict[LoadCase, float]

NonLinearLoadCombination

class viktor.external.scia.object.NonLinearLoadCombination(object_id, name, combination_type, load_cases, *, description=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by: create_nonlinear_load_combination()

class Type(value)¶

Bases: Enum

An enumeration.

ULTIMATE: Type = 0¶

SERVICEABILITY: Type = 1¶

property load_cases: Dict[LoadCase, float]¶

Return type: Dict[LoadCase, float]

ResultClass

class viktor.external.scia.object.ResultClass(object_id, name, combinations, nonlinear_combinations)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_result_class()

property combinations: List[LoadCombination]¶

Return type: List[LoadCombination]

property nonlinear_combinations: List[NonLinearLoadCombination]¶

Return type: List[NonLinearLoadCombination]

IntegrationStrip

class viktor.external.scia.object.IntegrationStrip(object_id, name, plane, point_1, point_2, width, effective_width_geometry=_EffectiveWidthGeometry.CONSTANT_SYMMETRIC, effective_width_definition=_EffectiveWidthDefinition.WIDTH)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_integration_strip()

property plane: Plane¶

Return type: Plane

SectionOnPlane

class viktor.external.scia.object.SectionOnPlane(object_id, name, point_1, point_2, draw=None, direction_of_cut=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_section_on_plane()

class Draw(value)¶

Bases: Enum

An enumeration.

UPRIGHT_TO_ELEMENT: Draw = 0¶

ELEMENT_PLANE: Draw = 1¶

X_DIRECTION: Draw = 2¶

Y_DIRECTION: Draw = 3¶

Z_DIRECTION: Draw = 4¶

ProjectData

class viktor.external.scia.object.ProjectData(*, name=None, part=None, description=None, author=None, date=None)¶

Bases: _SciaObject

New in v13.1.0

Basic project data.

Parameters

name (Optional[str]) – Project name (default: as defined in ESA model)
part (Optional[str]) – Project part name (default: as defined in ESA model)
description (Optional[str]) – Project description (default: as defined in ESA model)
author (Optional[str]) – Name of the author (default: as defined in ESA model)
date (Optional[str]) – Date of the last modification (default: as defined in ESA model)

MeshSetup

class viktor.external.scia.object.MeshSetup(*, average_1d=1.0, average_2d=1.0, division_2d_1d=50)¶

Bases: _SciaObject

Mesh settings parameters.

Parameters

average_1d (float) – Average size of cables, tendons, elements on subsoil, nonlinear soil spring [m] (default: 1.0).
average_2d (float) – Average size of 2d element/curved element [m] (default: 1.0).
division_2d_1d (int) – Division for 2D-1D upgrade (default: 50).

SolverSetup

class viktor.external.scia.object.SolverSetup(*, neglect_shear_force_deformation=None, bending_theory=None, solver_type=None, number_of_sections=None, reinforcement_coefficient=None)¶

Bases: _SciaObject

New in v13.1.0

Solver setup.

Parameters

neglect_shear_force_deformation (Optional[bool]) – Neglect shear force deformation (default: as defined in ESA model)
bending_theory (Optional[str]) – Bending theory of plate/shell analysis (‘mindlin’ | ‘kirchhoff’) (default: as defined in ESA model)
solver_type (Optional[str]) – Type of solver (‘direct’ | ‘iterative’) (default: as defined in ESA model)
number_of_sections (Optional[float]) – Number of sections on average member (default: as defined in ESA model)
reinforcement_coefficient (Optional[float]) – Coefficient for reinforcement (default: as defined in ESA model)

Concrete

class viktor.external.scia.object.Concrete(object_id, name, part, thermal_expansion=None, unit_mass=None, wet_density=None, e_modulus=None, poisson=None, g_modulus=None, log_decrement=None, specific_heat=None, thermal_conductivity=None, *, fck=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by update_concrete_material()

class ECPart(value)¶

Bases: Enum

GENERAL - concrete EN 1992-1-1
BRIDGES - concrete EN 1992-2

GENERAL: ECPart = 0¶

BRIDGES: ECPart = 1¶

property ec_part: ECPart¶

Return type: ECPart

FreeLoad

class viktor.external.scia.object.FreeLoad(object_id, name, load_case, direction, select, validity=None, load_type=None, c_sys=None)¶

Bases: _SciaObject, ABC

Abstract base class of all free loads.

Do not use this __init__ directly, but create the object by create_free_point_load(),: create_free_line_load() or create_free_surface_load()

class Direction(value)¶

Bases: Enum

An enumeration.

X: Direction = 0¶

Y: Direction = 1¶

Z: Direction = 2¶

class Select(value)¶

Bases: Enum

An enumeration.

AUTO: Select = 0¶

SELECT: Select = 1¶

class Type(value)¶

Bases: Enum

An enumeration.

FORCE: Type = 0¶

class Validity(value)¶

Bases: Enum

An enumeration.

ALL: Validity = 0¶

NEG_Z: Validity = 1¶

POS_Z: Validity = 2¶

FROM_TO: Validity = 3¶

ZERO_Z: Validity = 4¶

NEG_Z_INCL_ZERO: Validity = 5¶

POS_Z_INCL_ZERO: Validity = 6¶

class CSys(value)¶

Bases: Enum

An enumeration.

GLOBAL: CSys = 0¶

MEMBER_LCS: CSys = 1¶

LOAD_LCS: CSys = 2¶

class Location(value)¶

Bases: Enum

An enumeration.

LENGTH: Location = 0¶

PROJECTION: Location = 1¶

property load_case: LoadCase¶

Return type: LoadCase

FreeLineLoad

class viktor.external.scia.object.FreeLineLoad(object_id, name, load_case, point_1, point_2, direction, magnitude_1, magnitude_2, distribution=Distribution.TRAPEZOIDAL, validity=Validity.ALL, load_type=Type.FORCE, select=Select.AUTO, system=CSys.GLOBAL, location=Location.LENGTH)¶

Bases: FreeLoad

Do not use this __init__ directly, but create the object by create_free_line_load()

class Distribution(value)¶

Bases: Enum

An enumeration.

UNIFORM: Distribution = 0¶

TRAPEZOIDAL: Distribution = 1¶

FreePointLoad

class viktor.external.scia.object.FreePointLoad(object_id, name, load_case, direction, magnitude, position, load_type=Type.FORCE, validity=Validity.ALL, select=Select.AUTO, system=CSys.GLOBAL)¶

Bases: FreeLoad

Do not use this __init__ directly, but create the object by create_free_point_load()

FreeSurfaceLoad

class viktor.external.scia.object.FreeSurfaceLoad(object_id, name, load_case, direction, q1, q2=None, q3=None, points=None, distribution=None, load_type=None, validity=None, system=None, location=None, selection=None)¶

Bases: FreeLoad

Do not use this __init__ directly, but create the object by create_free_surface_load()

class Distribution(value)¶

Bases: Enum

An enumeration.

UNIFORM: Distribution = 0¶

DIR_X: Distribution = 1¶

DIR_Y: Distribution = 2¶

POINTS: Distribution = 3¶

property q2: Optional[float]¶

Return type: Optional[float]

property q3: Optional[float]¶

Return type: Optional[float]

property points: Optional[List[Tuple[float, float]]]¶

Return type: Optional[List[Tuple[float, float]]]

property distribution: Distribution¶

Return type: Distribution

property selection: Optional[List[Plane]]¶

Return type: Optional[List[Plane]]

LineLoad

class viktor.external.scia.object.LineLoad(object_id, name, load_case, beam, load_type, distribution, load_start, load_end, direction, c_sys, position_start, position_end, c_def, origin, ey, ez)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_line_load()

class CSys(value)¶

Bases: Enum

An enumeration.

GLOBAL: CSys = 0¶

LOCAL: CSys = 1¶

class CDef(value)¶

Bases: Enum

ABSOLUTE - absolute, where the coordinate must lie between 0 and the length of the beam
RELATIVE - relative, where the coordinate must lie between 0 and 1

ABSOLUTE: CDef = 0¶

RELATIVE: CDef = 1¶

class Direction(value)¶

Bases: Enum

An enumeration.

X: Direction = 0¶

Y: Direction = 1¶

Z: Direction = 2¶

class Distribution(value)¶

Bases: Enum

An enumeration.

UNIFORM: Distribution = 0¶

TRAPEZOIDAL: Distribution = 1¶

class Origin(value)¶

Bases: Enum

FROM_START - position is measured from the beginning of the beam
FROM_END - position is measured from the end of the beam

FROM_START: Origin = 0¶

FROM_END: Origin = 1¶

class Type(value)¶

Bases: Enum

An enumeration.

FORCE: Type = 0¶

SELF_WEIGHT: Type = 1¶

property beam: Beam¶

Return type: Beam

property load_case: LoadCase¶

Return type: LoadCase

LineMomentOnBeam

class viktor.external.scia.object.LineMomentOnBeam(object_id, name, beam, load_case, m1, m2=None, direction=None, c_def=None, position_x1=None, position_x2=None, origin=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_line_moment_on_beam().

class CDef(value)¶

Bases: Enum

ABSOLUTE - absolute, where the coordinate must lie between 0 and the length of the beam
RELATIVE - relative, where the coordinate must lie between 0 and 1

ABSOLUTE: CDef = 0¶

RELATIVE: CDef = 1¶

class Direction(value)¶

Bases: Enum

An enumeration.

X: Direction = 0¶

Y: Direction = 1¶

Z: Direction = 2¶

class Origin(value)¶

Bases: Enum

FROM_START - position is measured from the beginning of the beam
FROM_END - position is measured from the end of the beam

FROM_START: Origin = 0¶

FROM_END: Origin = 1¶

LineMomentOnPlane

class viktor.external.scia.object.LineMomentOnPlane(object_id, name, edge, load_case, m1, m2=None, direction=None, c_def=None, position_x1=None, position_x2=None, origin=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_line_moment_on_plane().

class CDef(value)¶

Bases: Enum

ABSOLUTE - absolute, where the coordinate must lie between 0 and the length of the plane edge
RELATIVE - relative, where the coordinate must lie between 0 and 1

ABSOLUTE: CDef = 0¶

RELATIVE: CDef = 1¶

class Direction(value)¶

Bases: Enum

An enumeration.

X: Direction = 0¶

Y: Direction = 1¶

Z: Direction = 2¶

class Origin(value)¶

Bases: Enum

FROM_START - position is measured from the beginning of the plane edge
FROM_END - position is measured from the end of the plane edge

FROM_START: Origin = 0¶

FROM_END: Origin = 1¶

property plane: Plane¶

Return type: Plane

LineForceSurface

class viktor.external.scia.object.LineForceSurface(object_id, name, edge, load_case, p1, p2=None, direction=None, location=None, c_sys=None, c_def=None, position_x1=None, position_x2=None, origin=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_line_load_on_plane()

class CSys(value)¶

Bases: Enum

An enumeration.

GLOBAL: CSys = 0¶

LOCAL: CSys = 1¶

class Direction(value)¶

Bases: Enum

An enumeration.

X: Direction = 0¶

Y: Direction = 1¶

Z: Direction = 2¶

class Distribution(value)¶

Bases: Enum

An enumeration.

UNIFORM: Distribution = 0¶

TRAPEZOIDAL: Distribution = 1¶

class Location(value)¶

Bases: Enum

An enumeration.

LENGTH: Location = 0¶

PROJECTION: Location = 1¶

class CDef(value)¶

Bases: Enum

ABSOLUTE - absolute, where the coordinate must lie between 0 and the length of the plane edge
RELATIVE - relative, where the coordinate must lie between 0 and 1

ABSOLUTE: CDef = 0¶

RELATIVE: CDef = 1¶

class Origin(value)¶

Bases: Enum

FROM_START - position is measured from the beginning of the plane edge
FROM_END - position is measured from the end of the plane edge

FROM_START: Origin = 0¶

FROM_END: Origin = 1¶

property plane: Plane¶

Return type: Plane

property load_case: LoadCase¶

Return type: LoadCase

property c_sys: CSys¶

Return type: CSys

property location: Location¶

Return type: Location

property distribution: Distribution¶

Return type: Distribution

property c_def: CDef¶

Return type: CDef

property position_x1: Optional[float]¶

Return type: Optional[float]

property position_x2: Optional[float]¶

Return type: Optional[float]

property origin: Origin¶

Return type: Origin

PointLoadNode

class viktor.external.scia.object.PointLoadNode(object_id, name, node, load_case, load, direction=None, c_sys=None, angle=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_point_load_node()

class CSys(value)¶

Bases: Enum

An enumeration.

GLOBAL: CSys = 0¶

LOCAL: CSys = 1¶

class Direction(value)¶

Bases: Enum

An enumeration.

X: Direction = 0¶

Y: Direction = 1¶

Z: Direction = 2¶

property node: Node¶

Return type: Node

property load_case: LoadCase¶

Return type: LoadCase

PointLoad

class viktor.external.scia.object.PointLoad(object_id, name, load_case, beam, direction, load_type, load_value, c_sys=None, c_def=None, position_x=None, origin=None, repeat=None, ey=None, ez=None, *, angle=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_point_load()

class CSys(value)¶

Bases: Enum

An enumeration.

GLOBAL: CSys = 0¶

LOCAL: CSys = 1¶

class CDef(value)¶

Bases: Enum

ABSOLUTE - absolute, where the coordinate must lie between 0 and the length of the beam
RELATIVE - relative, where the coordinate must lie between 0 and 1

ABSOLUTE: CDef = 0¶

RELATIVE: CDef = 1¶

class Direction(value)¶

Bases: Enum

An enumeration.

X: Direction = 0¶

Y: Direction = 1¶

Z: Direction = 2¶

class Distribution(value)¶

Bases: Enum

An enumeration.

UNIFORM: Distribution = 0¶

TRAPEZOIDAL: Distribution = 1¶

class Origin(value)¶

Bases: Enum

FROM_START - position is measured from the beginning of the beam
FROM_END - position is measured from the end of the beam

FROM_START: Origin = 0¶

FROM_END: Origin = 1¶

class Type(value)¶

Bases: Enum

An enumeration.

FORCE: Type = 0¶

property beam: Beam¶

Return type: Beam

property load_case: LoadCase¶

Return type: LoadCase

PointMomentNode

class viktor.external.scia.object.PointMomentNode(object_id, name, node, load_case, load, direction, c_sys)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_point_moment_node().

class CSys(value)¶

Bases: Enum

An enumeration.

GLOBAL: CSys = 0¶

LOCAL: CSys = 1¶

class Direction(value)¶

Bases: Enum

An enumeration.

X: Direction = 0¶

Y: Direction = 1¶

Z: Direction = 2¶

property node: Node¶

Return type: Node

property load_case: LoadCase¶

Return type: LoadCase

SurfaceLoad

class viktor.external.scia.object.SurfaceLoad(object_id, name, load_case, plane, direction, load_type, load_value, c_sys, location)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_surface_load()

class Direction(value)¶

Bases: Enum

An enumeration.

X: Direction = 0¶

Y: Direction = 1¶

Z: Direction = 2¶

class Type(value)¶

Bases: Enum

An enumeration.

FORCE: Type = 0¶

SELF_WEIGHT: Type = 1¶

class CSys(value)¶

Bases: Enum

An enumeration.

GLOBAL: CSys = 0¶

LOCAL: CSys = 1¶

class Location(value)¶

Bases: Enum

An enumeration.

LENGTH: Location = 0¶

PROJECTION: Location = 1¶

property plane: Plane¶

Return type: Plane

property load_case: LoadCase¶

Return type: LoadCase

ThermalLoad

class viktor.external.scia.object.ThermalLoad(object_id, name, load_case, beam, distribution, delta, left_delta, right_delta, top_delta, bottom_delta, position_start, position_end, c_def, origin)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_thermal_load()

class Distribution(value)¶

Bases: Enum

An enumeration.

CONSTANT: Distribution = 0¶

LINEAR: Distribution = 1¶

class CDef(value)¶

Bases: Enum

ABSOLUTE - absolute, where the coordinate must lie between 0 and the length of the beam
RELATIVE - relative, where the coordinate must lie between 0 and 1

ABSOLUTE: CDef = 0¶

RELATIVE: CDef = 1¶

class Origin(value)¶

Bases: Enum

FROM_START - position is measured from the beginning of the beam
FROM_END - position is measured from the end of the beam

FROM_START: Origin = 0¶

FROM_END: Origin = 1¶

property beam: Beam¶

Return type: Beam

property load_case: LoadCase¶

Return type: LoadCase

ThermalSurfaceLoad

class viktor.external.scia.object.ThermalSurfaceLoad(object_id, name, load_case, plane, delta=None, top_delta=None, bottom_delta=None)¶

Bases: _SciaObject

Do not use this __init__ directly, but create the object by create_thermal_surface_load()

class Distribution(value)¶

Bases: Enum

An enumeration.

CONSTANT: Distribution = 0¶

LINEAR: Distribution = 1¶

viktor.external.scia

CalcSetting​

ResultType​

SciaAnalysis​

Model​

OutputFileParser​

Layer​

Material​

NonLinearFunction​

Subsoil​

Orthotropy​

CrossSection​

RectangularCrossSection​

CircularCrossSection​

CircularHollowCrossSection​

ComposedCrossSection​

CircularComposedCrossSection​

NumericalCrossSection​

LibraryCrossSection​

Node​

Beam​

CrossLink​

ArbitraryProfileSpan​

ArbitraryProfile​

HingeOnBeam​

HingeOnPlane​

Plane​

LineSupport​

LineSupportLine​

LineSupportSurface​

SurfaceSupportSurface​

OpenSlab​

InternalEdge​

PointSupport​

PointSupportLine​

RigidArm​

SectionOnBeam​

LoadGroup​

LoadCase​

PermanentLoadCase​

VariableLoadCase​

LoadCombination​

NonLinearLoadCombination​

ResultClass​

IntegrationStrip​

SectionOnPlane​

ProjectData​

MeshSetup​

SolverSetup​

Concrete​

FreeLoad​

FreeLineLoad​

FreePointLoad​

FreeSurfaceLoad​

LineLoad​

LineMomentOnBeam​

LineMomentOnPlane​

LineForceSurface​

PointLoadNode​

PointLoad​

PointMomentNode​

SurfaceLoad​

ThermalLoad​

ThermalSurfaceLoad​

CalcSetting

ResultType

SciaAnalysis

Model

OutputFileParser

Layer

Material

NonLinearFunction

Subsoil

Orthotropy

CrossSection

RectangularCrossSection

CircularCrossSection

CircularHollowCrossSection

ComposedCrossSection

CircularComposedCrossSection

NumericalCrossSection

LibraryCrossSection

Node

Beam

CrossLink

ArbitraryProfileSpan

ArbitraryProfile

HingeOnBeam

HingeOnPlane

Plane

LineSupport

LineSupportLine

LineSupportSurface

SurfaceSupportSurface

OpenSlab

InternalEdge

PointSupport

PointSupportLine

RigidArm

SectionOnBeam

LoadGroup

LoadCase

PermanentLoadCase

VariableLoadCase

LoadCombination

NonLinearLoadCombination

ResultClass

IntegrationStrip

SectionOnPlane

ProjectData

MeshSetup

SolverSetup

Concrete

FreeLoad

FreeLineLoad

FreePointLoad

FreeSurfaceLoad

LineLoad

LineMomentOnBeam

LineMomentOnPlane

LineForceSurface

PointLoadNode

PointLoad

PointMomentNode

SurfaceLoad

ThermalLoad

ThermalSurfaceLoad