Skip to main content
Version: 12.9.0

viktor.external.scia

CalcSetting

ResultType

class viktor.external.scia.scia.ResultType(value)

Bases: enum.Enum

Enumeration of result types:

NONE: viktor.external.scia.scia.ResultType = 'XML'
MODEL: viktor.external.scia.scia.ResultType = 'MODEL'
ENGINEERING_REPORT: viktor.external.scia.scia.ResultType = 'ENGINEERING_REPORT'

SciaAnalysis

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: viktor.external.external_program.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:

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)

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()
property layers: Tuple[viktor.external.scia.object.Layer, ...]
Return type

Tuple[Layer, …]

property concrete_materials: Tuple[viktor.external.scia.object.Concrete, ...]
Return type

Tuple[Concrete, …]

property nonlinear_functions: Tuple[viktor.external.scia.object.NonLinearFunction, ...]
Return type

Tuple[NonLinearFunction, …]

property subsoils: Tuple[viktor.external.scia.object.Subsoil, ...]
Return type

Tuple[Subsoil, …]

property orthotropy_objects: Tuple[viktor.external.scia.object.Orthotropy, ...]
Return type

Tuple[Orthotropy, …]

property cross_sections: Tuple[viktor.external.scia.object.CrossSection, ...]
Return type

Tuple[CrossSection, …]

property nodes: Tuple[viktor.external.scia.object.Node, ...]
Return type

Tuple[Node, …]

property beams: Tuple[viktor.external.scia.object.Beam, ...]
Return type

Tuple[Beam, …]

property arbitrary_profiles: Tuple[viktor.external.scia.object.ArbitraryProfile, ...]
Return type

Tuple[ArbitraryProfile, …]

property hinges_on_beam: Tuple[viktor.external.scia.object.HingeOnBeam, ...]
Return type

Tuple[HingeOnBeam, …]

property hinges_on_plane: Tuple[viktor.external.scia.object.HingeOnPlane, ...]
Return type

Tuple[HingeOnPlane, …]

property sections_on_beam: Tuple[viktor.external.scia.object.SectionOnBeam, ...]
Return type

Tuple[SectionOnBeam, …]

property sections_on_plane: Tuple[viktor.external.scia.object.SectionOnPlane, ...]
Return type

Tuple[SectionOnPlane, …]

property planes: Tuple[viktor.external.scia.object.Plane, ...]
Return type

Tuple[Plane, …]

property open_slabs: Tuple[viktor.external.scia.object.OpenSlab, ...]
Return type

Tuple[OpenSlab, …]

property internal_edges: Tuple[viktor.external.scia.object.InternalEdge, ...]
Return type

Tuple[InternalEdge, …]

property rigid_arms: Tuple[viktor.external.scia.object.RigidArm, ...]
Return type

Tuple[RigidArm, …]

property point_supports: Tuple[viktor.external.scia.object.PointSupport, ...]
Return type

Tuple[PointSupport, …]

property point_supports_line: Tuple[viktor.external.scia.object.PointSupportLine, ...]
Return type

Tuple[PointSupportLine, …]

property line_supports_line: Tuple[viktor.external.scia.object.LineSupportLine, ...]
Return type

Tuple[LineSupportLine, …]

property line_supports_surface: Tuple[viktor.external.scia.object.LineSupportSurface, ...]
Return type

Tuple[LineSupportSurface, …]

property surface_supports: Tuple[viktor.external.scia.object.SurfaceSupportSurface, ...]
Return type

Tuple[SurfaceSupportSurface, …]

property load_cases: Tuple[viktor.external.scia.object.LoadCase, ...]
Return type

Tuple[LoadCase, …]

property load_groups: Tuple[viktor.external.scia.object.LoadGroup, ...]
Return type

Tuple[LoadGroup, …]

property load_combinations: Tuple[viktor.external.scia.object.LoadCombination, ...]
Return type

Tuple[LoadCombination, …]

property nonlinear_load_combinations: Tuple[viktor.external.scia.object.NonLinearLoadCombination, ...]
Return type

Tuple[NonLinearLoadCombination, …]

property result_classes: Tuple[viktor.external.scia.object.ResultClass, ...]
Return type

Tuple[ResultClass, …]

property point_loads_node: Tuple[viktor.external.scia.object.PointLoadNode, ...]
Return type

Tuple[PointLoadNode, …]

property point_loads: Tuple[viktor.external.scia.object.PointLoad, ...]
Return type

Tuple[PointLoad, …]

property point_moments_node: Tuple[viktor.external.scia.object.PointMomentNode, ...]
Return type

Tuple[PointMomentNode, …]

property line_loads: Tuple[viktor.external.scia.object.LineLoad, ...]
Return type

Tuple[LineLoad, …]

property line_moments_on_beam: Tuple[viktor.external.scia.object.LineMomentOnBeam, ...]
Return type

Tuple[LineMomentOnBeam, …]

property line_moments_on_plane: Tuple[viktor.external.scia.object.LineMomentOnPlane, ...]
Return type

Tuple[LineMomentOnPlane, …]

property line_force_surface_list: Tuple[viktor.external.scia.object.LineForceSurface, ...]
Return type

Tuple[LineForceSurface, …]

property surface_loads: Tuple[viktor.external.scia.object.SurfaceLoad, ...]
Return type

Tuple[SurfaceLoad, …]

property thermal_loads: Tuple[viktor.external.scia.object.ThermalLoad, ...]
Return type

Tuple[ThermalLoad, …]

property thermal_surface_loads: Tuple[viktor.external.scia.object.ThermalSurfaceLoad, ...]
Return type

Tuple[ThermalSurfaceLoad, …]

property free_surface_loads: Tuple[viktor.external.scia.object.FreeSurfaceLoad, ...]
Return type

Tuple[FreeSurfaceLoad, …]

property free_line_loads: Tuple[viktor.external.scia.object.FreeLineLoad, ...]
Return type

Tuple[FreeLineLoad, …]

property free_point_loads: Tuple[viktor.external.scia.object.FreePointLoad, ...]
Return type

Tuple[FreePointLoad, …]

property integration_strips: Tuple[viktor.external.scia.object.IntegrationStrip, ...]
Return type

Tuple[IntegrationStrip, …]

property mesh_setup: viktor.external.scia.object.MeshSetup
Return type

MeshSetup

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/m3]

  • wet_density (Optional[float]) – wet density in [kg/m3]

  • 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_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_arbitrary_profile(name, beam, c_def, cross_section, spans)

Method to construct an arbitrary profile.

Parameters
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)

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

Return type

LoadCombination

create_nonlinear_load_combination(load_type, load_cases, *, name=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}’)

Return type

NonLinearLoadCombination

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

Method to construct a result class.

Parameters
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.

Return type

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

Returns

  • File if as_file = True

  • BytesIO if as_file = False (default)

SciaParsingError

exception viktor.external.scia.scia.SciaParsingError

Bases: Exception

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

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)

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

Material

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

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)

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

class Type(value)

Bases: enum.Enum

An enumeration.

TRANSLATION: viktor.external.scia.object.NonLinearFunction.Type = 0
ROTATION: viktor.external.scia.object.NonLinearFunction.Type = 1
NONLINEAR_SUBSOIL: viktor.external.scia.object.NonLinearFunction.Type = 2
class Support(value)

Bases: enum.Enum

An enumeration.

RIGID: viktor.external.scia.object.NonLinearFunction.Support = 0
FREE: viktor.external.scia.object.NonLinearFunction.Support = 1
FLEXIBLE: viktor.external.scia.object.NonLinearFunction.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)

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

class C1z(value)

Bases: enum.Enum

An enumeration.

FLEXIBLE: viktor.external.scia.object.Subsoil.C1z = 0
NONLINEAR_FUNCTION: viktor.external.scia.object.Subsoil.C1z = 1
property nonlinear_function: Optional[viktor.external.scia.object.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)

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

CrossSection

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

Abstract base class of all cross sections.

RectangularCrossSection

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

Bases: viktor.external.scia.object.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: viktor.external.scia.object.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: viktor.external.scia.object.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: viktor.external.scia.object.CrossSection, abc.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: viktor.external.scia.object.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: viktor.external.scia.object.CrossSection

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

Node

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

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)

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

property begin_node: viktor.external.scia.object.Node
Return type

Node

property end_node: viktor.external.scia.object.Node
Return type

Node

property cross_section: viktor.external.scia.object.CrossSection
Return type

CrossSection

property ez: float
Return type

float

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.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: viktor.external.scia.object.ArbitraryProfileSpan.TypeOfCss = 0
PARAM_HAUNCH: viktor.external.scia.object.ArbitraryProfileSpan.TypeOfCss = 1
TWO_CSS: viktor.external.scia.object.ArbitraryProfileSpan.TypeOfCss = 2
class Alignment(value)

Bases: enum.Enum

DEFAULT: viktor.external.scia.object.ArbitraryProfileSpan.Alignment = 0
CENTER_LINE: viktor.external.scia.object.ArbitraryProfileSpan.Alignment = 1
TOP_SURFACE: viktor.external.scia.object.ArbitraryProfileSpan.Alignment = 2
BOTTOM_SURFACE: viktor.external.scia.object.ArbitraryProfileSpan.Alignment = 3
LEFT_SURFACE: viktor.external.scia.object.ArbitraryProfileSpan.Alignment = 4
RIGHT_SURFACE: viktor.external.scia.object.ArbitraryProfileSpan.Alignment = 5
TOP_LEFT: viktor.external.scia.object.ArbitraryProfileSpan.Alignment = 6
TOP_RIGHT: viktor.external.scia.object.ArbitraryProfileSpan.Alignment = 7
BOTTOM_LEFT: viktor.external.scia.object.ArbitraryProfileSpan.Alignment = 8
BOTTOM_RIGHT: viktor.external.scia.object.ArbitraryProfileSpan.Alignment = 9
property cross_section_start: viktor.external.scia.object.CrossSection
Return type

CrossSection

property cross_section_end: viktor.external.scia.object.CrossSection
Return type

CrossSection

ArbitraryProfile

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

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

class CDef(value)

Bases: enum.Enum

  • ABSOLUTE - absolute

  • RELATIVE - relative

ABSOLUTE: viktor.external.scia.object.ArbitraryProfile.CDef = 0
RELATIVE: viktor.external.scia.object.ArbitraryProfile.CDef = 1
property beam: viktor.external.scia.object.Beam
Return type

Beam

property cross_section: viktor.external.scia.object.CrossSection
Return type

CrossSection

property spans: List[viktor.external.scia.object.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)

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

class Position(value)

Bases: enum.Enum

An enumeration.

BEGIN: viktor.external.scia.object.HingeOnBeam.Position = 0
END: viktor.external.scia.object.HingeOnBeam.Position = 1
BOTH: viktor.external.scia.object.HingeOnBeam.Position = 2
class Freedom(value)

Bases: enum.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: viktor.external.scia.object.HingeOnBeam.Freedom = 0
RIGID: viktor.external.scia.object.HingeOnBeam.Freedom = 1
FLEXIBLE: viktor.external.scia.object.HingeOnBeam.Freedom = 2
property beam: viktor.external.scia.object.Beam
Return type

Beam

property freedom: Tuple[viktor.external.scia.object.HingeOnBeam.Freedom, viktor.external.scia.object.HingeOnBeam.Freedom, viktor.external.scia.object.HingeOnBeam.Freedom, viktor.external.scia.object.HingeOnBeam.Freedom, viktor.external.scia.object.HingeOnBeam.Freedom, viktor.external.scia.object.HingeOnBeam.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)

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

class CDef(value)

Bases: enum.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: viktor.external.scia.object.HingeOnPlane.CDef = 0
RELATIVE: viktor.external.scia.object.HingeOnPlane.CDef = 1
class Freedom(value)

Bases: enum.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: viktor.external.scia.object.HingeOnPlane.Freedom = 0
RIGID: viktor.external.scia.object.HingeOnPlane.Freedom = 1
FLEXIBLE: viktor.external.scia.object.HingeOnPlane.Freedom = 2
class Origin(value)

Bases: enum.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: viktor.external.scia.object.HingeOnPlane.Origin = 0
FROM_END: viktor.external.scia.object.HingeOnPlane.Origin = 1
property plane: viktor.external.scia.object.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)

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

class FEMModel(value)

Bases: enum.Enum

An enumeration.

ISOTROPIC: viktor.external.scia.object.Plane.FEMModel = 0
ORTHOTROPIC: viktor.external.scia.object.Plane.FEMModel = 1
class Type(value)

Bases: enum.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: viktor.external.scia.object.Plane.Type = 0
WALL: viktor.external.scia.object.Plane.Type = 1
SHELL: viktor.external.scia.object.Plane.Type = 2
property corner_nodes: List[viktor.external.scia.object.Node]
Return type

List[Node]

property internal_nodes: List[viktor.external.scia.object.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)

Abstract base class of all line supports.

class Constraint(value)

Bases: enum.Enum

An enumeration.

FIXED: viktor.external.scia.object.LineSupport.Constraint = 0
HINGED: viktor.external.scia.object.LineSupport.Constraint = 1
SLIDING: viktor.external.scia.object.LineSupport.Constraint = 2
CUSTOM: viktor.external.scia.object.LineSupport.Constraint = 3
class Type(value)

Bases: enum.Enum

An enumeration.

LINE: viktor.external.scia.object.LineSupport.Type = 0
FOUNDATION_STRIP: viktor.external.scia.object.LineSupport.Type = 1
WALL: viktor.external.scia.object.LineSupport.Type = 2
class Freedom(value)

Bases: enum.Enum

An enumeration.

FREE: viktor.external.scia.object.LineSupport.Freedom = 0
RIGID: viktor.external.scia.object.LineSupport.Freedom = 1
FLEXIBLE: viktor.external.scia.object.LineSupport.Freedom = 2
RIGID_PRESS_ONLY: viktor.external.scia.object.LineSupport.Freedom = 3
RIGID_TENSION_ONLY: viktor.external.scia.object.LineSupport.Freedom = 4
FLEXIBLE_PRESS_ONLY: viktor.external.scia.object.LineSupport.Freedom = 5
FLEXIBLE_TENSION_ONLY: viktor.external.scia.object.LineSupport.Freedom = 6
NONLINEAR: viktor.external.scia.object.LineSupport.Freedom = 7
class CSys(value)

Bases: enum.Enum

An enumeration.

GLOBAL: viktor.external.scia.object.LineSupport.CSys = 0
LOCAL: viktor.external.scia.object.LineSupport.CSys = 1
class CDef(value)

Bases: enum.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: viktor.external.scia.object.LineSupport.CDef = 0
RELATIVE: viktor.external.scia.object.LineSupport.CDef = 1
class Extent(value)

Bases: enum.Enum

  • FULL - support across the full length

  • SPAN - support across a span

FULL: viktor.external.scia.object.LineSupport.Extent = 0
SPAN: viktor.external.scia.object.LineSupport.Extent = 1
class Origin(value)

Bases: enum.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: viktor.external.scia.object.LineSupport.Origin = 0
FROM_END: viktor.external.scia.object.LineSupport.Origin = 1
property constraint: viktor.external.scia.object.LineSupport.Constraint
Return type

Constraint

property freedom: Tuple[viktor.external.scia.object.LineSupport.Freedom, viktor.external.scia.object.LineSupport.Freedom, viktor.external.scia.object.LineSupport.Freedom, viktor.external.scia.object.LineSupport.Freedom, viktor.external.scia.object.LineSupport.Freedom, viktor.external.scia.object.LineSupport.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[viktor.external.scia.object.NonLinearFunction]
Return type

Optional[NonLinearFunction]

property function_y: Optional[viktor.external.scia.object.NonLinearFunction]
Return type

Optional[NonLinearFunction]

property function_z: Optional[viktor.external.scia.object.NonLinearFunction]
Return type

Optional[NonLinearFunction]

property function_rx: Optional[viktor.external.scia.object.NonLinearFunction]
Return type

Optional[NonLinearFunction]

property function_ry: Optional[viktor.external.scia.object.NonLinearFunction]
Return type

Optional[NonLinearFunction]

property function_rz: Optional[viktor.external.scia.object.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: viktor.external.scia.object.LineSupport

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

property beam: viktor.external.scia.object.Beam
Return type

Beam

property spring_type: viktor.external.scia.object.LineSupport.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: viktor.external.scia.object.LineSupport

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

property plane: viktor.external.scia.object.Plane
Return type

Plane

SurfaceSupportSurface

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

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

property plane: viktor.external.scia.object.Plane
Return type

Plane

property subsoil: viktor.external.scia.object.Subsoil
Return type

Subsoil

OpenSlab

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

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

property plane: viktor.external.scia.object.Plane
Return type

Plane

property corner_nodes: List[viktor.external.scia.object.Node]
Return type

List[Node]

InternalEdge

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

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

property plane: viktor.external.scia.object.Plane
Return type

Plane

property node_1: viktor.external.scia.object.Node
Return type

Node

property node_2: viktor.external.scia.object.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)

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

class Constraint(value)

Bases: enum.Enum

An enumeration.

FIXED: viktor.external.scia.object.PointSupport.Constraint = 0
HINGED: viktor.external.scia.object.PointSupport.Constraint = 1
SLIDING: viktor.external.scia.object.PointSupport.Constraint = 2
CUSTOM: viktor.external.scia.object.PointSupport.Constraint = 3
class Type(value)

Bases: enum.Enum

An enumeration.

STANDARD: viktor.external.scia.object.PointSupport.Type = 0
PAD_FOUNDATION: viktor.external.scia.object.PointSupport.Type = 1
COLUMN: viktor.external.scia.object.PointSupport.Type = 2
class Freedom(value)

Bases: enum.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: viktor.external.scia.object.PointSupport.Freedom = 0
RIGID: viktor.external.scia.object.PointSupport.Freedom = 1
FLEXIBLE: viktor.external.scia.object.PointSupport.Freedom = 2
class CSys(value)

Bases: enum.Enum

An enumeration.

GLOBAL: viktor.external.scia.object.PointSupport.CSys = 0
LOCAL: viktor.external.scia.object.PointSupport.CSys = 1
property node: viktor.external.scia.object.Node
Return type

Node

property constraint: viktor.external.scia.object.PointSupport.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)

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

class Freedom(value)

Bases: enum.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: viktor.external.scia.object.PointSupportLine.Freedom = 0
RIGID: viktor.external.scia.object.PointSupportLine.Freedom = 1
FLEXIBLE: viktor.external.scia.object.PointSupportLine.Freedom = 2
class CSys(value)

Bases: enum.Enum

An enumeration.

GLOBAL: viktor.external.scia.object.PointSupportLine.CSys = 0
LOCAL: viktor.external.scia.object.PointSupportLine.CSys = 1
class CDef(value)

Bases: enum.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: viktor.external.scia.object.PointSupportLine.CDef = 0
RELATIVE: viktor.external.scia.object.PointSupportLine.CDef = 1
class Origin(value)

Bases: enum.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: viktor.external.scia.object.PointSupportLine.Origin = 0
FROM_END: viktor.external.scia.object.PointSupportLine.Origin = 1

RigidArm

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

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

property master_node: viktor.external.scia.object.Node
Return type

Node

property slave_node: viktor.external.scia.object.Node
Return type

Node

SectionOnBeam

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

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

class CDef(value)

Bases: enum.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: viktor.external.scia.object.SectionOnBeam.CDef = 0
RELATIVE: viktor.external.scia.object.SectionOnBeam.CDef = 1
class Origin(value)

Bases: enum.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: viktor.external.scia.object.SectionOnBeam.Origin = 0
FROM_END: viktor.external.scia.object.SectionOnBeam.Origin = 1
property beam: viktor.external.scia.object.Beam
Return type

Beam

LoadGroup

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

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

class LoadOption(value)

Bases: enum.Enum

An enumeration.

PERMANENT: viktor.external.scia.object.LoadGroup.LoadOption = 0
VARIABLE: viktor.external.scia.object.LoadGroup.LoadOption = 1
ACCIDENTAL: viktor.external.scia.object.LoadGroup.LoadOption = 2
SEISMIC: viktor.external.scia.object.LoadGroup.LoadOption = 3
class RelationOption(value)

Bases: enum.Enum

An enumeration.

STANDARD: viktor.external.scia.object.LoadGroup.RelationOption = 0
EXCLUSIVE: viktor.external.scia.object.LoadGroup.RelationOption = 1
TOGETHER: viktor.external.scia.object.LoadGroup.RelationOption = 2
class LoadTypeOption(value)

Bases: enum.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: viktor.external.scia.object.LoadGroup.LoadTypeOption = 0
CAT_B: viktor.external.scia.object.LoadGroup.LoadTypeOption = 1
CAT_C: viktor.external.scia.object.LoadGroup.LoadTypeOption = 2
CAT_D: viktor.external.scia.object.LoadGroup.LoadTypeOption = 3
CAT_E: viktor.external.scia.object.LoadGroup.LoadTypeOption = 4
CAT_F: viktor.external.scia.object.LoadGroup.LoadTypeOption = 5
CAT_G: viktor.external.scia.object.LoadGroup.LoadTypeOption = 6
CAT_H: viktor.external.scia.object.LoadGroup.LoadTypeOption = 7
SNOW: viktor.external.scia.object.LoadGroup.LoadTypeOption = 8
WIND: viktor.external.scia.object.LoadGroup.LoadTypeOption = 11
TEMPERATURE: viktor.external.scia.object.LoadGroup.LoadTypeOption = 12
RAIN_WATER: viktor.external.scia.object.LoadGroup.LoadTypeOption = 20
CONSTRUCTION_LOADS: viktor.external.scia.object.LoadGroup.LoadTypeOption = 21
property relation: Optional[viktor.external.scia.object.LoadGroup.RelationOption]
Return type

Optional[RelationOption]

property load_type: Optional[viktor.external.scia.object.LoadGroup.LoadTypeOption]
Return type

Optional[LoadTypeOption]

LoadCase

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

Abstract base class of all load cases.

class ActionType(value)

Bases: enum.Enum

An enumeration.

PERMANENT: viktor.external.scia.object.LoadCase.ActionType = 0
VARIABLE: viktor.external.scia.object.LoadCase.ActionType = 1
class PermanentLoadType(value)

Bases: enum.Enum

An enumeration.

SELF_WEIGHT: viktor.external.scia.object.LoadCase.PermanentLoadType = 0
STANDARD: viktor.external.scia.object.LoadCase.PermanentLoadType = 1
PRIMARY_EFFECT: viktor.external.scia.object.LoadCase.PermanentLoadType = 2
class VariableLoadType(value)

Bases: enum.Enum

An enumeration.

STATIC: viktor.external.scia.object.LoadCase.VariableLoadType = 0
PRIMARY_EFFECT: viktor.external.scia.object.LoadCase.VariableLoadType = 1
class Specification(value)

Bases: enum.Enum

An enumeration.

STANDARD: viktor.external.scia.object.LoadCase.Specification = 100
TEMPERATURE: viktor.external.scia.object.LoadCase.Specification = 101
STATIC_WIND: viktor.external.scia.object.LoadCase.Specification = 102
EARTHQUAKE: viktor.external.scia.object.LoadCase.Specification = 103
SNOW: viktor.external.scia.object.LoadCase.Specification = 104
class Duration(value)

Bases: enum.Enum

An enumeration.

LONG: viktor.external.scia.object.LoadCase.Duration = 0
MEDIUM: viktor.external.scia.object.LoadCase.Duration = 1
SHORT: viktor.external.scia.object.LoadCase.Duration = 2
INSTANTANEOUS: viktor.external.scia.object.LoadCase.Duration = 3
class Direction(value)

Bases: enum.Enum

  • NEG_Z - -Z

  • POS_Z - +Z

  • NEG_Y - -Y

  • POS_Y - +Y

  • NEG_X - -X

  • POS_X - +X

NEG_Z: viktor.external.scia.object.LoadCase.Direction = 0
POS_Z: viktor.external.scia.object.LoadCase.Direction = 1
NEG_Y: viktor.external.scia.object.LoadCase.Direction = 2
POS_Y: viktor.external.scia.object.LoadCase.Direction = 3
NEG_X: viktor.external.scia.object.LoadCase.Direction = 4
POS_X: viktor.external.scia.object.LoadCase.Direction = 5
property load_group: viktor.external.scia.object.LoadGroup
Return type

LoadGroup

abstract property load_type: Union[viktor.external.scia.object.LoadCase.PermanentLoadType, viktor.external.scia.object.LoadCase.VariableLoadType]
Return type

Union[PermanentLoadType, VariableLoadType]

abstract property direction: Optional[viktor.external.scia.object.LoadCase.Direction]
Return type

Optional[Direction]

abstract property specification: Optional[viktor.external.scia.object.LoadCase.Specification]
Return type

Optional[Specification]

abstract property duration: Optional[viktor.external.scia.object.LoadCase.Duration]
Return type

Optional[Duration]

abstract property master: Optional[str]
Return type

Optional[str]

abstract property primary_effect: Optional[viktor.external.scia.object.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: viktor.external.scia.object.LoadCase

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

property load_type: viktor.external.scia.object.LoadCase.PermanentLoadType
Return type

PermanentLoadType

property direction: Optional[viktor.external.scia.object.LoadCase.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[viktor.external.scia.object.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: viktor.external.scia.object.LoadCase

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

property load_type: viktor.external.scia.object.LoadCase.VariableLoadType
Return type

VariableLoadType

property master: Optional[str]
Return type

Optional[str]

property specification: Optional[viktor.external.scia.object.LoadCase.Specification]
Return type

Optional[Specification]

property duration: Optional[viktor.external.scia.object.LoadCase.Duration]
Return type

Optional[Duration]

property direction: None
Return type

None

property primary_effect: Optional[viktor.external.scia.object.LoadCase]
Return type

Optional[LoadCase]

LoadCombination

class viktor.external.scia.object.LoadCombination(object_id, name, combination_type, load_cases)

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

class Type(value)

Bases: enum.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: viktor.external.scia.object.LoadCombination.Type = 0
ENVELOPE_SERVICEABILITY: viktor.external.scia.object.LoadCombination.Type = 1
LINEAR_ULTIMATE: viktor.external.scia.object.LoadCombination.Type = 2
LINEAR_SERVICEABILITY: viktor.external.scia.object.LoadCombination.Type = 3
EN_ULS_SET_B: viktor.external.scia.object.LoadCombination.Type = 4
EN_ACC_ONE: viktor.external.scia.object.LoadCombination.Type = 5
EN_ACC_TWO: viktor.external.scia.object.LoadCombination.Type = 6
EN_SEISMIC: viktor.external.scia.object.LoadCombination.Type = 7
EN_SLS_CHAR: viktor.external.scia.object.LoadCombination.Type = 8
EN_SLS_FREQ: viktor.external.scia.object.LoadCombination.Type = 9
EN_SLS_QUASI: viktor.external.scia.object.LoadCombination.Type = 10
EN_ULS_SET_C: viktor.external.scia.object.LoadCombination.Type = 11
property load_cases: Dict[viktor.external.scia.object.LoadCase, float]
Return type

Dict[LoadCase, float]

NonLinearLoadCombination

class viktor.external.scia.object.NonLinearLoadCombination(object_id, name, combination_type, load_cases)
Do not use this __init__ directly, but create the object by

create_nonlinear_load_combination()

class Type(value)

Bases: enum.Enum

An enumeration.

ULTIMATE: viktor.external.scia.object.NonLinearLoadCombination.Type = 0
SERVICEABILITY: viktor.external.scia.object.NonLinearLoadCombination.Type = 1
property load_cases: Dict[viktor.external.scia.object.LoadCase, float]
Return type

Dict[LoadCase, float]

ResultClass

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

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

property combinations: List[viktor.external.scia.object.LoadCombination]
Return type

List[LoadCombination]

property nonlinear_combinations: List[viktor.external.scia.object.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)

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

property plane: viktor.external.scia.object.Plane
Return type

Plane

SectionOnPlane

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

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

class Draw(value)

Bases: enum.Enum

An enumeration.

UPRIGHT_TO_ELEMENT: viktor.external.scia.object.SectionOnPlane.Draw = 0
ELEMENT_PLANE: viktor.external.scia.object.SectionOnPlane.Draw = 1
X_DIRECTION: viktor.external.scia.object.SectionOnPlane.Draw = 2
Y_DIRECTION: viktor.external.scia.object.SectionOnPlane.Draw = 3
Z_DIRECTION: viktor.external.scia.object.SectionOnPlane.Draw = 4

MeshSetup

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

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).

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)

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

class ECPart(value)

Bases: enum.Enum

  • GENERAL - concrete EN 1992-1-1

  • BRIDGES - concrete EN 1992-2

GENERAL: viktor.external.scia.object.Concrete.ECPart = 0
BRIDGES: viktor.external.scia.object.Concrete.ECPart = 1
property ec_part: viktor.external.scia.object.Concrete.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)

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.Enum

An enumeration.

X: viktor.external.scia.object.FreeLoad.Direction = 0
Y: viktor.external.scia.object.FreeLoad.Direction = 1
Z: viktor.external.scia.object.FreeLoad.Direction = 2
class Select(value)

Bases: enum.Enum

An enumeration.

AUTO: viktor.external.scia.object.FreeLoad.Select = 0
SELECT: viktor.external.scia.object.FreeLoad.Select = 1
class Type(value)

Bases: enum.Enum

An enumeration.

FORCE: viktor.external.scia.object.FreeLoad.Type = 0
class Validity(value)

Bases: enum.Enum

An enumeration.

ALL: viktor.external.scia.object.FreeLoad.Validity = 0
NEG_Z: viktor.external.scia.object.FreeLoad.Validity = 1
POS_Z: viktor.external.scia.object.FreeLoad.Validity = 2
FROM_TO: viktor.external.scia.object.FreeLoad.Validity = 3
ZERO_Z: viktor.external.scia.object.FreeLoad.Validity = 4
NEG_Z_INCL_ZERO: viktor.external.scia.object.FreeLoad.Validity = 5
POS_Z_INCL_ZERO: viktor.external.scia.object.FreeLoad.Validity = 6
class CSys(value)

Bases: enum.Enum

An enumeration.

GLOBAL: viktor.external.scia.object.FreeLoad.CSys = 0
MEMBER_LCS: viktor.external.scia.object.FreeLoad.CSys = 1
LOAD_LCS: viktor.external.scia.object.FreeLoad.CSys = 2
class Location(value)

Bases: enum.Enum

An enumeration.

LENGTH: viktor.external.scia.object.FreeLoad.Location = 0
PROJECTION: viktor.external.scia.object.FreeLoad.Location = 1
property load_case: viktor.external.scia.object.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: viktor.external.scia.object.FreeLoad

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

class Distribution(value)

Bases: enum.Enum

An enumeration.

UNIFORM: viktor.external.scia.object.FreeLineLoad.Distribution = 0
TRAPEZOIDAL: viktor.external.scia.object.FreeLineLoad.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: viktor.external.scia.object.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: viktor.external.scia.object.FreeLoad

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

class Distribution(value)

Bases: enum.Enum

An enumeration.

UNIFORM: viktor.external.scia.object.FreeSurfaceLoad.Distribution = 0
DIR_X: viktor.external.scia.object.FreeSurfaceLoad.Distribution = 1
DIR_Y: viktor.external.scia.object.FreeSurfaceLoad.Distribution = 2
POINTS: viktor.external.scia.object.FreeSurfaceLoad.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: viktor.external.scia.object.FreeSurfaceLoad.Distribution
Return type

Distribution

property selection: Optional[List[viktor.external.scia.object.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)

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

class CSys(value)

Bases: enum.Enum

An enumeration.

GLOBAL: viktor.external.scia.object.LineLoad.CSys = 0
LOCAL: viktor.external.scia.object.LineLoad.CSys = 1
class CDef(value)

Bases: enum.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: viktor.external.scia.object.LineLoad.CDef = 0
RELATIVE: viktor.external.scia.object.LineLoad.CDef = 1
class Direction(value)

Bases: enum.Enum

An enumeration.

X: viktor.external.scia.object.LineLoad.Direction = 0
Y: viktor.external.scia.object.LineLoad.Direction = 1
Z: viktor.external.scia.object.LineLoad.Direction = 2
class Distribution(value)

Bases: enum.Enum

An enumeration.

UNIFORM: viktor.external.scia.object.LineLoad.Distribution = 0
TRAPEZOIDAL: viktor.external.scia.object.LineLoad.Distribution = 1
class Origin(value)

Bases: enum.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: viktor.external.scia.object.LineLoad.Origin = 0
FROM_END: viktor.external.scia.object.LineLoad.Origin = 1
class Type(value)

Bases: enum.Enum

An enumeration.

FORCE: viktor.external.scia.object.LineLoad.Type = 0
SELF_WEIGHT: viktor.external.scia.object.LineLoad.Type = 1
property beam: viktor.external.scia.object.Beam
Return type

Beam

property load_case: viktor.external.scia.object.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)

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

class CDef(value)

Bases: enum.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: viktor.external.scia.object.LineMomentOnBeam.CDef = 0
RELATIVE: viktor.external.scia.object.LineMomentOnBeam.CDef = 1
class Direction(value)

Bases: enum.Enum

An enumeration.

X: viktor.external.scia.object.LineMomentOnBeam.Direction = 0
Y: viktor.external.scia.object.LineMomentOnBeam.Direction = 1
Z: viktor.external.scia.object.LineMomentOnBeam.Direction = 2
class Origin(value)

Bases: enum.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: viktor.external.scia.object.LineMomentOnBeam.Origin = 0
FROM_END: viktor.external.scia.object.LineMomentOnBeam.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)

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

class CDef(value)

Bases: enum.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: viktor.external.scia.object.LineMomentOnPlane.CDef = 0
RELATIVE: viktor.external.scia.object.LineMomentOnPlane.CDef = 1
class Direction(value)

Bases: enum.Enum

An enumeration.

X: viktor.external.scia.object.LineMomentOnPlane.Direction = 0
Y: viktor.external.scia.object.LineMomentOnPlane.Direction = 1
Z: viktor.external.scia.object.LineMomentOnPlane.Direction = 2
class Origin(value)

Bases: enum.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: viktor.external.scia.object.LineMomentOnPlane.Origin = 0
FROM_END: viktor.external.scia.object.LineMomentOnPlane.Origin = 1
property plane: viktor.external.scia.object.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)

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

class CSys(value)

Bases: enum.Enum

An enumeration.

GLOBAL: viktor.external.scia.object.LineForceSurface.CSys = 0
LOCAL: viktor.external.scia.object.LineForceSurface.CSys = 1
class Direction(value)

Bases: enum.Enum

An enumeration.

X: viktor.external.scia.object.LineForceSurface.Direction = 0
Y: viktor.external.scia.object.LineForceSurface.Direction = 1
Z: viktor.external.scia.object.LineForceSurface.Direction = 2
class Distribution(value)

Bases: enum.Enum

An enumeration.

UNIFORM: viktor.external.scia.object.LineForceSurface.Distribution = 0
TRAPEZOIDAL: viktor.external.scia.object.LineForceSurface.Distribution = 1
class Location(value)

Bases: enum.Enum

An enumeration.

LENGTH: viktor.external.scia.object.LineForceSurface.Location = 0
PROJECTION: viktor.external.scia.object.LineForceSurface.Location = 1
class CDef(value)

Bases: enum.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: viktor.external.scia.object.LineForceSurface.CDef = 0
RELATIVE: viktor.external.scia.object.LineForceSurface.CDef = 1
class Origin(value)

Bases: enum.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: viktor.external.scia.object.LineForceSurface.Origin = 0
FROM_END: viktor.external.scia.object.LineForceSurface.Origin = 1
property plane: viktor.external.scia.object.Plane
Return type

Plane

property load_case: viktor.external.scia.object.LoadCase
Return type

LoadCase

property c_sys: viktor.external.scia.object.LineForceSurface.CSys
Return type

CSys

property location: viktor.external.scia.object.LineForceSurface.Location
Return type

Location

property distribution: viktor.external.scia.object.LineForceSurface.Distribution
Return type

Distribution

property c_def: viktor.external.scia.object.LineForceSurface.CDef
Return type

CDef

property position_x1: Optional[float]
Return type

Optional[float]

property position_x2: Optional[float]
Return type

Optional[float]

property origin: viktor.external.scia.object.LineForceSurface.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)

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

class CSys(value)

Bases: enum.Enum

An enumeration.

GLOBAL: viktor.external.scia.object.PointLoadNode.CSys = 0
LOCAL: viktor.external.scia.object.PointLoadNode.CSys = 1
class Direction(value)

Bases: enum.Enum

An enumeration.

X: viktor.external.scia.object.PointLoadNode.Direction = 0
Y: viktor.external.scia.object.PointLoadNode.Direction = 1
Z: viktor.external.scia.object.PointLoadNode.Direction = 2
property node: viktor.external.scia.object.Node
Return type

Node

property load_case: viktor.external.scia.object.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)

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

class CSys(value)

Bases: enum.Enum

An enumeration.

GLOBAL: viktor.external.scia.object.PointLoad.CSys = 0
LOCAL: viktor.external.scia.object.PointLoad.CSys = 1
class CDef(value)

Bases: enum.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: viktor.external.scia.object.PointLoad.CDef = 0
RELATIVE: viktor.external.scia.object.PointLoad.CDef = 1
class Direction(value)

Bases: enum.Enum

An enumeration.

X: viktor.external.scia.object.PointLoad.Direction = 0
Y: viktor.external.scia.object.PointLoad.Direction = 1
Z: viktor.external.scia.object.PointLoad.Direction = 2
class Distribution(value)

Bases: enum.Enum

An enumeration.

UNIFORM: viktor.external.scia.object.PointLoad.Distribution = 0
TRAPEZOIDAL: viktor.external.scia.object.PointLoad.Distribution = 1
class Origin(value)

Bases: enum.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: viktor.external.scia.object.PointLoad.Origin = 0
FROM_END: viktor.external.scia.object.PointLoad.Origin = 1
class Type(value)

Bases: enum.Enum

An enumeration.

FORCE: viktor.external.scia.object.PointLoad.Type = 0
property beam: viktor.external.scia.object.Beam
Return type

Beam

property load_case: viktor.external.scia.object.LoadCase
Return type

LoadCase

PointMomentNode

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

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

class CSys(value)

Bases: enum.Enum

An enumeration.

GLOBAL: viktor.external.scia.object.PointMomentNode.CSys = 0
LOCAL: viktor.external.scia.object.PointMomentNode.CSys = 1
class Direction(value)

Bases: enum.Enum

An enumeration.

X: viktor.external.scia.object.PointMomentNode.Direction = 0
Y: viktor.external.scia.object.PointMomentNode.Direction = 1
Z: viktor.external.scia.object.PointMomentNode.Direction = 2
property node: viktor.external.scia.object.Node
Return type

Node

property load_case: viktor.external.scia.object.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)

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

class Direction(value)

Bases: enum.Enum

An enumeration.

X: viktor.external.scia.object.SurfaceLoad.Direction = 0
Y: viktor.external.scia.object.SurfaceLoad.Direction = 1
Z: viktor.external.scia.object.SurfaceLoad.Direction = 2
class Type(value)

Bases: enum.Enum

An enumeration.

FORCE: viktor.external.scia.object.SurfaceLoad.Type = 0
SELF_WEIGHT: viktor.external.scia.object.SurfaceLoad.Type = 1
class CSys(value)

Bases: enum.Enum

An enumeration.

GLOBAL: viktor.external.scia.object.SurfaceLoad.CSys = 0
LOCAL: viktor.external.scia.object.SurfaceLoad.CSys = 1
class Location(value)

Bases: enum.Enum

An enumeration.

LENGTH: viktor.external.scia.object.SurfaceLoad.Location = 0
PROJECTION: viktor.external.scia.object.SurfaceLoad.Location = 1
property plane: viktor.external.scia.object.Plane
Return type

Plane

property load_case: viktor.external.scia.object.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)

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

class Distribution(value)

Bases: enum.Enum

An enumeration.

CONSTANT: viktor.external.scia.object.ThermalLoad.Distribution = 0
LINEAR: viktor.external.scia.object.ThermalLoad.Distribution = 1
class CDef(value)

Bases: enum.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: viktor.external.scia.object.ThermalLoad.CDef = 0
RELATIVE: viktor.external.scia.object.ThermalLoad.CDef = 1
class Origin(value)

Bases: enum.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: viktor.external.scia.object.ThermalLoad.Origin = 0
FROM_END: viktor.external.scia.object.ThermalLoad.Origin = 1
property beam: viktor.external.scia.object.Beam
Return type

Beam

property load_case: viktor.external.scia.object.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)

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

class Distribution(value)

Bases: enum.Enum

An enumeration.

CONSTANT: viktor.external.scia.object.ThermalSurfaceLoad.Distribution = 0
LINEAR: viktor.external.scia.object.ThermalSurfaceLoad.Distribution = 1