Version: 13

viktor.external.axisvm

AxisVMAnalysis

class viktor.external.axisvm.AxisVMAnalysis(model, *, return_results=True, return_model=False, report_template=None)¶

Bases: ExternalProgram

Perform an analysis using AxisVM on a third-party worker. To start an analysis call the method execute(), with an appropriate timeout (in seconds).

To retrieve the results call the method get_results(), after execute(). The model file can be retrieved by calling get_model_file() and the result by calling get_result_file().

Usage:

axisvm_analysis = AxisVMAnalysis(model, return_results=True, return_model=True)
axisvm_analysis.execute(timeout=10)
results = axisvm_analysis.get_results()
model_file = axisvm_analysis.get_model_file()
result_file = axisvm_analysis.get_result_file()

Exceptions which can be raised during calculation:

ExecutionError: generic error. Error message provides more information

Parameters

model (Model) – AxisVM model (Model)
return_results (bool) – If True, an analysis will be run and the result file is returned.
return_model (bool) – If True, the model file is returned.
report_template (Union[BytesIO, File, None]) – (optional) report template that is added to AxisVM file

get_results()¶

Retrieve the results (only if return_results = True). execute() must be called first.

The format of the returned dictionary is:

{
    'Forces': <dict>,
    'Displacements': <dict>,
    'Sections': <dict>
}

Return type: dict

get_model_file(*, as_file=False)¶

Retrieve the model file (only if return_model = True). execute() must be called first.

Parameters

as_file (bool) – Return as BytesIO (default) or File

New in v13.5.0

Return type

Union[BytesIO, File, None]

get_result_file(*, as_file=False)¶

Retrieve the result file (only if return_results = True). execute() must be called first.

Parameters

as_file (bool) – Return as BytesIO (default) or File

New in v13.5.0

Return type

Union[BytesIO, File, None]

CircleArc

class viktor.external.axisvm.CircleArc(center, normal_vector, alpha)¶

Circular arc defined by its center, normal vector and angle. Used in various methods, in conjunction with a start and end point.

Parameters

center (Tuple[float, float, float]) – (x, y, z) position [m] of the arc’s center point.
normal_vector (Tuple[float, float, float]) – (x, y, z) component [m] of the arc plane’s normal vector.
alpha (float) – signed angle [rad]. Positive angle is counterclockwise, from the start point.

Object

class viktor.external.axisvm.Object(id_)¶

Bases: ABC

Abstract base class of all AxisVM objects. Do not use this __init__ directly.

property id: int¶

Object id.

Return type: int

Reference

class viktor.external.axisvm.Reference(id_)¶

Bases: Object, ABC

Do not use this __init__ directly, but create the object from Model

Material

class viktor.external.axisvm.Material(id_, name)¶

Bases: Object

Do not use this __init__ directly, but create the object from Model

class DesignCode(value)¶

Bases: Enum

National design code.

OTHER: DesignCode = 0¶

HUNGARIAN_MSZ: DesignCode = 1¶

EURO_CODE: DesignCode = 2¶

ROMANIAN_STAS: DesignCode = 4¶

DUTCH_NEN: DesignCode = 5¶

GERMAN_DIN1045_1: DesignCode = 6¶

SWISS_SIA26X: DesignCode = 7¶

EURO_CODE_GER: DesignCode = 8¶

ITALIAN: DesignCode = 9¶

EURO_CODE_AUSTRIAN: DesignCode = 10¶

EURO_CODE_UK: DesignCode = 11¶

EURO_CODE_NL: DesignCode = 12¶

EURO_CODE_FIN: DesignCode = 13¶

EURO_CODE_RO: DesignCode = 14¶

EURO_CODE_HU: DesignCode = 15¶

EURO_CODE_CZ: DesignCode = 16¶

EURO_CODE_B: DesignCode = 17¶

EURO_CODE_PL: DesignCode = 18¶

EURO_CODE_DK: DesignCode = 19¶

EURO_CODE_S: DesignCode = 20¶

US: DesignCode = 21¶

CA_NBCC: DesignCode = 22¶

CA_ONTARIO: DesignCode = 23¶

CA_BRIDGE: DesignCode = 24¶

EURO_CODE_SK: DesignCode = 25¶

property name: str¶

Name of the material.

Return type: str

Node

class viktor.external.axisvm.Node(id_, x, y, z)¶

Bases: Object

Do not use this __init__ directly, but create the object from Model

property x: float¶

X-coordinate.

Return type: float

property y: float¶

Y-coordinate.

Return type: float

property z: float¶

Z-coordinate.

Return type: float

CrossSection

class viktor.external.axisvm.CrossSection(id_, name)¶

Bases: Object

Do not use this __init__ directly, but create the object from Model

class Process(value)¶

Bases: Enum

Manufacturing process.

OTHER: Process = 0¶

ROLLED: Process = 1¶

WELDED: Process = 2¶

COLD_FORMED: Process = 3¶

property name: str¶

Name of the cross-section.

Return type: str

Line

class viktor.external.axisvm.Line(id_, interface, node1, node2)¶

Bases: Object

Do not use this __init__ directly, but create the object from Model

property start_node: Node¶

Start node of the line.

Return type: Node

property end_node: Node¶

End node of the line.

Return type: Node

define_as_beam(material, css_start, css_end=None, *, local_z_reference=None)¶

Define the line as beam with given material and cross-section.

Parameters

material (Material) – material of the beam.
css_start (CrossSection) – cross-section at the start node of the beam.
css_end (Optional[CrossSection]) – cross-section at the start node of the beam (default: same as css_start).
local_z_reference (Optional[Reference]) – local z-reference (must be of type vector) (default: auto).

Return type

Member

split_by_number(n)¶

Split the line in ‘n’ equal parts.

Parameters: n (int) – number of parts after the split.
Return type: None

Member

class viktor.external.axisvm.Member(line, type_)¶

Bases: Object

Do not use this __init__ directly, but create the object from Model

Domain

class viktor.external.axisvm.Domain(id_, interface)¶

Bases: Object

Do not use this __init__ directly, but create the object from Model

class SurfaceType(value)¶

Bases: Enum

Finite element type.

HOLE: SurfaceType = 0¶

MEMBRANE_STRESS: SurfaceType = 1¶

MEMBRANE_STRAIN: SurfaceType = 2¶

PLATE: SurfaceType = 3¶

SHELL: SurfaceType = 4¶

class MeshType(value)¶

Bases: Enum

Contour division method.

ADAPTIVE: MeshType = 0¶

UNIFORM: MeshType = 1¶

class MeshGeometry(value)¶

Bases: Enum

Mesh geometry type.

TRIANGLE: MeshGeometry = 0¶

QUAD: MeshGeometry = 1¶

MIXED: MeshGeometry = 2¶

class EccentricityType(value)¶

Bases: Enum

Type of eccentricity.

CONSTANT: EccentricityType = 1¶

ONE_WAY: EccentricityType = 2¶

TWO_WAY: EccentricityType = 3¶

TOP_ALIGNED: EccentricityType = 4¶

BOTTOM_ALIGNED: EccentricityType = 5¶

generate_mesh(mesh_geometry, mesh_size, *, mesh_type=MeshType.UNIFORM, fit_to_point_loads=None, fit_to_line_loads=None, fit_to_surface_loads=None, quad_mesh_quality=2)¶

Generate a mesh on the domain.

Parameters

mesh_geometry (MeshGeometry) – mesh geometry type.
mesh_size (float) – average mesh size [m].
mesh_type (MeshType) – contour division method (default: uniform).
fit_to_point_loads (Optional[float]) – fit mesh to point loads (default: false).
fit_to_line_loads (Optional[float]) – fit mesh to line loads (default: false).
fit_to_surface_loads (Optional[float]) – fit mesh to surface loads (default: false)
quad_mesh_quality (int) – smoothing quality (1-6) (default: 2)

Return type

None

set_eccentricity(eccentricity_type, *, ecc_1=None, p1=None, ecc_2=None, p2=None, ecc_3=None, p3=None)¶

Set eccentricity for the domain.

Parameters

eccentricity_type (EccentricityType) – type of eccentricity.
ecc_1 (Optional[float]) – eccentricity [m] at reference point 1.
p1 (Optional[Tuple[float, float, float]]) – (x, y, z) position [m] of reference point 1.
ecc_2 (Optional[float]) – eccentricity [m] at reference point 2.
p2 (Optional[Tuple[float, float, float]]) – (x, y, z) position [m] of reference point 2.
ecc_3 (Optional[float]) – eccentricity [m] at reference point 3.
p3 (Optional[Tuple[float, float, float]]) – (x, y, z) position [m] of reference point 3.

Return type

None

NodeSupport

class viktor.external.axisvm.NodeSupport(id_)¶

Bases: Object

Do not use this __init__ directly, but create the object from Model

LineSupport

class viktor.external.axisvm.LineSupport(id_)¶

Bases: Object

Do not use this __init__ directly, but create the object from Model

class NonLinearity(value)¶

Bases: Enum

Type of non-linear behavior.

LINEAR: NonLinearity = 0¶

TENSION_ONLY: NonLinearity = 1¶

COMPRESSION_ONLY: NonLinearity = 2¶

LoadCase

class viktor.external.axisvm.LoadCase(id_, name)¶

Bases: Object

Do not use this __init__ directly, but create the object from Model

property name: str¶

Name of the load case.

Return type: str

Load

class viktor.external.axisvm.Load(id_)¶

Bases: Object

Do not use this __init__ directly, but create the object from Model

class DistributionType(value)¶

Bases: Enum

An enumeration.

GLOBAL: DistributionType = 0¶

LOCAL: DistributionType = 1¶

PROJECTED: DistributionType = 2¶

class SurfaceDistributionType(value)¶

Bases: Enum

An enumeration.

SURFACE: SurfaceDistributionType = 0¶

PROJECTED: SurfaceDistributionType = 1¶

class System(value)¶

Bases: Enum

An enumeration.

GLOBAL: System = 0¶

LOCAL: System = 1¶

REFERENCE: System = 2¶

class Axis(value)¶

Bases: Enum

An enumeration.

X: Axis = 0¶

Y: Axis = 1¶

Z: Axis = 2¶

XX: Axis = 3¶

YY: Axis = 4¶

ZZ: Axis = 5¶

LoadCombination

class viktor.external.axisvm.LoadCombination(id_, name)¶

Bases: Object

Do not use this __init__ directly, but create the object from Model

class Type(value)¶

Bases: Enum

An enumeration.

OTHER: Type = 0¶

SLS_1: Type = 1¶

SLS_CHAR: Type = 1¶

SLS_2: Type = 2¶

SLS_FREQ: Type = 2¶

SLS_3: Type = 3¶

SLS_QUASI: Type = 3¶

ULS_1: Type = 4¶

ULS: Type = 4¶

ULS_2: Type = 5¶

ULS_SEISMIC: Type = 5¶

ULS_3: Type = 6¶

ULS_EXCEPTIONAL: Type = 6¶

ULS_ALL: Type = 7¶

ULS_AB: Type = 8¶

ULS_A: Type = 9¶

ULS_B: Type = 10¶

ULS_ALL_AB: Type = 11¶

ULS_A1: Type = 12¶

ULS_A2: Type = 13¶

ULS_A3: Type = 14¶

ULS_A4: Type = 15¶

ULS_A5: Type = 16¶

ULS_A6: Type = 17¶

ULS_A7: Type = 18¶

ULS_A8: Type = 19¶

property name: str¶

Name of the load case.

Return type: str

Section

class viktor.external.axisvm.Section(id_, interface, name)¶

Bases: Object

Do not use this __init__ directly, but create the object from Model

property name: str¶

Name of the section.

Return type: str

ReferenceInterface

class viktor.external.axisvm.ReferenceInterface¶

Bases: _Interface

Do not use this __init__ directly, but use Model.references

create_point(x, y, z)¶

Create a reference point.

Parameters

x (float) – x-position [m].
y (float) – y-position [m].
z (float) – z-position [m].

Return type

Reference

create_vector(point_1, point_2)¶

Create a reference vector.

Parameters

point_1 (Tuple[float, float, float]) – (x, y, z) position [m] of the start point.
point_2 (Tuple[float, float, float]) – (x, y, z) position [m] of the end point.

Return type

Reference

create_axis(point_1, point_2)¶

Create a reference axis.

Parameters

point_1 (Tuple[float, float, float]) – (x, y, z) position [m] of the start point.
point_2 (Tuple[float, float, float]) – (x, y, z) position [m] of the end point.

Return type

Reference

create_plane(point_1, point_2, point_3)¶

Create a reference plane.

Parameters

point_1 (Tuple[float, float, float]) – (x, y, z) position [m] of point 1.
point_2 (Tuple[float, float, float]) – (x, y, z) position [m] of point 2.
point_3 (Tuple[float, float, float]) – (x, y, z) position [m] of point 3.

Return type

Reference

create_angle(angle)¶

Create a reference angle.

Parameters: angle (float) – angle [rad].
Return type: Reference

MaterialInterface

class viktor.external.axisvm.MaterialInterface¶

Bases: _Interface

Do not use this __init__ directly, but use Model.materials

create_concrete_eurocode(*, e_x, e_y=None, e_z=None, nu_x, nu_y=None, nu_z=None, alpha_x=0.0, alpha_y=None, alpha_z=None, rho, f_ck, gamma_c, alpha_cc, phi_t=0.0, material_code=None, name=None)¶

Create a concrete material according to the Eurocode.

Parameters

e_x (float) – Young’s modulus of elasticity [kN/m2] in local x-direction.
e_y (Optional[float]) – Young’s modulus of elasticity [kN/m2] in local y-direction (default = e_x).
e_z (Optional[float]) – Young’s modulus of elasticity [kN/m2] in local z-direction (default = e_x).
nu_x (float) – Poisson’s ratio [-] in local x-direction (0 <= nu <= 0.5).
nu_y (Optional[float]) – Poisson’s ratio [-] in local y-direction (0 <= nu <= 0.5) (default = nu_x).
nu_z (Optional[float]) – Poisson’s ratio [-] in local z-direction (0 <= nu <= 0.5) (default = nu_x).
alpha_x (float) – thermal expansion coefficient [1/C] in local x-direction (default = 0.0).
alpha_y (Optional[float]) – thermal expansion coefficient [1/C] in local y-direction (default = alpha_x).
alpha_z (Optional[float]) – thermal expansion coefficient [1/C] in local z-direction (default = alpha_x).
rho (float) – density [kg/m3].
f_ck (float) – characteristic compressive cylinder strength [kN/m2] at 28 days.
gamma_c (float) – safety factor [-].
alpha_cc (float) – concrete strength-reduction factor for sustained loading [-].
phi_t (float) – creeping factor [-] (default = 0.0).
material_code (Optional[str]) – material code name, as shown in the interface (default: auto).
name (Optional[str]) – material name, as shown in the interface (default: auto).

Return type

Material

add_from_catalog(name, national_design_code)¶

Adds a material from the catalog.

Parameters

name (str) – name of the material to be added (must exist in the corresponding national design code).
national_design_code (DesignCode) – national design code in which the material with given name resides.

Return type

Material

NodeInterface

class viktor.external.axisvm.NodeInterface¶

Bases: _Interface

Do not use this __init__ directly, but use Model.nodes

create(x, y, z)¶

Create a node at the given position and with given degree-of-freedom.

Parameters

x (float) – x-position [m].
y (float) – y-position [m].
z (float) – z-position [m].

Return type

Node

CrossSectionInterface

class viktor.external.axisvm.CrossSectionInterface¶

Bases: _Interface

Do not use this __init__ directly, but use Model.cross_sections

create_circular(diameter, *, name=None)¶

Create a circular cross-section with given diameter.

Parameters

diameter (float) – diameter [m] of the cross-section.
name (Optional[str]) – name of the cross-section (must be unique) (default: auto).

Return type

CrossSection

create_rectangular(width, height, *, process=Process.OTHER, name=None)¶

Create a rectangular cross-section with given width and height.

Parameters

width (float) – width [m] of the cross-section.
height (float) – height [m] of the cross-section.
process (Process) – process (default: other).
name (Optional[str]) – name of the cross-section (must be unique) (default: auto).

Return type

CrossSection

LineInterface

class viktor.external.axisvm.LineInterface¶

Bases: _Interface

Do not use this __init__ directly, but use Model.lines

create(start_node, end_node, circle_arc=None)¶

Create a line between start and end node.

Parameters

start_node (Node) – start node.
end_node (Node) – end node.
circle_arc (Optional[CircleArc]) – circular arc between the nodes (default: straight line).

Return type

Line

define_as_beam(line, material, css_start, css_end=None, *, local_z_reference=None)¶

Define a line as beam with given material and cross-section.

Parameters

line (Line) – line to define as beam.
material (Material) – material of the beam.
css_start (CrossSection) – cross-section at the start node of the beam.
css_end (Optional[CrossSection]) – cross-section at the start node of the beam (default: same as css_start).
local_z_reference (Optional[Reference]) – local z-reference (must be of type vector) (default: auto).

Return type

Member

split_by_number(line, n)¶

Split a line in ‘n’ equal parts.

Parameters

line (Line) – line to split.
n (int) – number of parts after the split.

Return type

None

DomainInterface

class viktor.external.axisvm.DomainInterface¶

Bases: _Interface

Do not use this __init__ directly, but use Model.domains

create(lines, *, surface_type, thickness, material)¶

Create a domain from given lines.

Parameters

lines (List[Line]) – lines to create a domain from (lines must form a closed loop!).
surface_type (SurfaceType) – finite element surface type.
thickness (float) – thickness [m] of the surface.
material (Material) – material of the surface.

Return type

Domain

generate_mesh_on_domains(domains, mesh_geometry, mesh_size, *, mesh_type=MeshType.UNIFORM, fit_to_point_loads=None, fit_to_line_loads=None, fit_to_surface_loads=None, quad_mesh_quality=2)¶

Generate a mesh on one or more domains.

Parameters

domains (List[Domain]) – domain(s) to generate the mesh on.
mesh_geometry (MeshGeometry) – mesh geometry type.
mesh_size (float) – average mesh size [m].
mesh_type (MeshType) – contour division method (default: uniform).
fit_to_point_loads (Optional[float]) – fit mesh to point loads (default: false).
fit_to_line_loads (Optional[float]) – fit mesh to line loads (default: false).
fit_to_surface_loads (Optional[float]) – fit mesh to surface loads (default: false)
quad_mesh_quality (int) – smoothing quality (1-6) (default: 2)

Return type

None

set_eccentricity(domain, eccentricity_type, *, ecc_1=None, p1=None, ecc_2=None, p2=None, ecc_3=None, p3=None)¶

Set eccentricity for a domain.

Parameters

domain (Domain) – domain to set eccentricity.
eccentricity_type (EccentricityType) – type of eccentricity.
ecc_1 (Optional[float]) – eccentricity [m] at reference point 1.
p1 (Optional[Tuple[float, float, float]]) – (x, y, z) position [m] of reference point 1.
ecc_2 (Optional[float]) – eccentricity [m] at reference point 2.
p2 (Optional[Tuple[float, float, float]]) – (x, y, z) position [m] of reference point 2.
ecc_3 (Optional[float]) – eccentricity [m] at reference point 3.
p3 (Optional[Tuple[float, float, float]]) – (x, y, z) position [m] of reference point 3.

Return type

None

NodeSupportInterface

class viktor.external.axisvm.NodeSupportInterface(lines)¶

Bases: _Interface

Do not use this __init__ directly, but use Model.node_supports

create_relative_to_member(node, *, stiffness_x=0.0, stiffness_y=0.0, stiffness_z=0.0, stiffness_xx=0.0, stiffness_yy=0.0, stiffness_zz=0.0, resistance_x=0.0, resistance_y=0.0, resistance_z=0.0, resistance_xx=0.0, resistance_yy=0.0, resistance_zz=0.0, non_linearity_x=NonLinearity.LINEAR, non_linearity_y=NonLinearity.LINEAR, non_linearity_z=NonLinearity.LINEAR, non_linearity_xx=NonLinearity.LINEAR, non_linearity_yy=NonLinearity.LINEAR, non_linearity_zz=NonLinearity.LINEAR)¶

Create a nodal support, relative to the member’s local coordinate system.

Parameters

node (Node) – node to create the support on. Must be an end-point of a member of type beam or rib.
stiffness_x (float) – translational stiffness [kN/m] in local x-direction (default = 0.0).
stiffness_y (float) – translational stiffness [kN/m] in local y-direction (default = 0.0).
stiffness_z (float) – translational stiffness [kN/m] in local z-direction (default = 0.0).
stiffness_xx (float) – rotational stiffness [kNm/rad] around the local x-axis (default = 0.0).
stiffness_yy (float) – rotational stiffness [kNm/rad] around the local y-axis (default = 0.0).
stiffness_zz (float) – rotational stiffness [kNm/rad] around the local z-axis (default = 0.0).
resistance_x (float) – translational resistance [kN/m] in local x-direction (default = 0.0).
resistance_y (float) – translational resistance [kN/m] in local y-direction (default = 0.0).
resistance_z (float) – translational resistance [kN/m] in local z-direction (default = 0.0).
resistance_xx (float) – rotational resistance [kNm/m] around the local x-axis (default = 0.0).
resistance_yy (float) – rotational resistance [kNm/m] around the local y-axis (default = 0.0).
resistance_zz (float) – rotational resistance [kNm/m] around the local z-axis (default = 0.0).
non_linearity_x (NonLinearity) – translational non-linear behaviour in local x-direction (default: linear).
non_linearity_y (NonLinearity) – translational non-linear behaviour in local y-direction (default: linear).
non_linearity_z (NonLinearity) – translational non-linear behaviour in local z-direction (default: linear).
non_linearity_xx (NonLinearity) – rotational non-linear behaviour around the local x-axis (default: linear).
non_linearity_yy (NonLinearity) – rotational non-linear behaviour around the local y-axis (default: linear).
non_linearity_zz (NonLinearity) – rotational non-linear behaviour around the local z-axis (default: linear).

Return type

NodeSupport

LineSupportInterface

class viktor.external.axisvm.LineSupportInterface¶

Bases: _Interface

Do not use this __init__ directly, but use Model.line_supports

create_on_member(member, k_x, k_y, k_z, *, non_linearity_x=NonLinearity.LINEAR, non_linearity_y=NonLinearity.LINEAR, non_linearity_z=NonLinearity.LINEAR, resistance_fx=0.0, resistance_fy=0.0, resistance_fz=0.0)¶

Create a line support on a member (beam), in the member’s coordinate system.

Parameters

member (Member) – member (beam) to create the line support on.
k_x (float) – stiffness [kN/m/m] in the local x-direction.
k_y (float) – stiffness [kN/m/m] in the local y-direction.
k_z (float) – stiffness [kN/m/m] in the local z-direction.
non_linearity_x (NonLinearity) – non-linear behaviour in the local x-direction (default: linear).
non_linearity_y (NonLinearity) – non-linear behaviour in the local y-direction (default: linear).
non_linearity_z (NonLinearity) – non-linear behaviour in the local z-direction (default: linear).
resistance_fx (float) – resistance [kN/m] in the local x-direction (default: 0.0).
resistance_fy (float) – resistance [kN/m] in the local y-direction (default: 0.0).
resistance_fz (float) – resistance [kN/m] in the local z-direction (default: 0.0).

Return type

LineSupport

LoadCaseInterface

class viktor.external.axisvm.LoadCaseInterface¶

Bases: _Interface

Do not use this __init__ directly, but use Model.load_cases

create(name=None)¶

Create a load case.

Parameters: name (Optional[str]) – name of the load case (default: auto).
Return type: LoadCase

LoadInterface

class viktor.external.axisvm.LoadInterface¶

Bases: _Interface

Do not use this __init__ directly, but use Model.loads

create_domain_linear(load_case, domain, load, *, component, point_1, point_2, point_3, distribution_type=DistributionType.GLOBAL, load_on_hole=False)¶

Create a linear distributed load on a domain.

Parameters

load_case (LoadCase) – load case to add the load to.
domain (Domain) – domain to create the load on.
load (Tuple[float, float, float]) – magnitude of the load at (point_1, point_2, point_3) [kN].
component (Axis) – direction of the load (X, Y, Z only).
point_1 (Tuple[float, float, float]) – (x, y, z) position [m] of reference point 1.
point_2 (Tuple[float, float, float]) – (x, y, z) position [m] of reference point 2.
point_3 (Tuple[float, float, float]) – (x, y, z) position [m] of reference point 3.
distribution_type (DistributionType) – distribution type (default: GLOBAL).
load_on_hole (bool) – apply load on hole (default: False -> loads disappear on holes).

Return type

Load

create_domain_constant(load_case, domain, load, *, distribution_type=SurfaceDistributionType.SURFACE, system=System.GLOBAL)¶

Create a constant distributed load on a domain.

Parameters

load_case (LoadCase) – load case to add the load to.
domain (Domain) – domain to create the load on.
load (Tuple[float, float, float]) – magnitude of the load (x, y, z) [kN].
distribution_type (SurfaceDistributionType) – distribution type (default: SURFACE).
system (System) – coordinate system (default: GLOBAL).

Return type

Load

create_domain_self_weight(load_case, domain)¶

Create a self-weight load on a domain.

Parameters

load_case (LoadCase) – load case to add the load to.
domain (Domain) – domain to create the load on.

Return type

Load

create_beam_self_weight(load_case, member)¶

Create a self-weight load on a member (beam).

Parameters

load_case (LoadCase) – load case to add the load to.
member (Member) – member to create the load on.

Return type

Load

LoadCombinationInterface

class viktor.external.axisvm.LoadCombinationInterface¶

Bases: _Interface

Do not use this __init__ directly, but use Model.load_combinations

create(combination_type, load_case_factors, *, name=None)¶

Create a load combination from given load cases and factors.

Parameters

combination_type (Type) – load combination type.
load_case_factors (Dict[LoadCase, float]) – factorized load cases {load_case: factor}.
name (Optional[str]) – name of the load combination (default: auto).

Return type

LoadCombination

SectionInterface

class viktor.external.axisvm.SectionInterface¶

Bases: _Interface

Do not use this __init__ directly, but use Model.sections

create(start_point, end_point, normal_vector, *, name=None)¶

Create a section (segment) from coordinates, to obtain results from.

Parameters

start_point (Tuple[float, float, float]) – (x, y, z) position [m] of the section’s start point.
end_point (Tuple[float, float, float]) – (x, y, z) position [m] of the section’s end point.
normal_vector (Tuple[float, float, float]) – (x, y, z) components [m] of the section plane’s normal vector.
name (Optional[str]) – name of the section (default: auto).

Return type

Section

ResultInterface

class viktor.external.axisvm.ResultInterface(nodes, node_supports, lines, sections)¶

nodal_displacements(nodes=None, *, by_load_case=True)¶

Request nodal displacements for all load cases or combinations.

Parameters

nodes (Optional[List[Node]]) – nodes to request the results for, or None for all nodes (default: all nodes).
by_load_case (bool) – True to get result on all load cases; False to get results on all load combinations.

Return type

None

nodal_support_forces(node_supports=None, *, by_load_case=True)¶

Request nodal support forces for all load cases or combinations.

Parameters

node_supports (Optional[List[NodeSupport]]) – node supports to request the results for, or None for all node supports (default: all node supports).
by_load_case (bool) – True to get result on all load cases; False to get results on all load combinations.

Return type

None

line_forces(members=None, *, by_load_case=True)¶

Request line forces for all load cases or combinations.

Parameters

members (Optional[List[Member]]) – members to request the results for, or None for all members (default: all members).
by_load_case (bool) – True to get the result on all load cases; False to get results on all load combinations.

Return type

None

section_surface_forces(sections, cases, chain_index=1)¶

Request section chain’s surface forces for given load combinations.

Parameters

sections (List[Section]) – sections to request the results for, or None for all sections (default: all sections).
cases (List[LoadCombination]) – list of load combinations to request the results for.
chain_index (int) – index of the segment chain to request the results for (default: 1).

Return type

None

section_surface_stresses(sections, cases, chain_index=1)¶

Request section chain’s surface stresses for given load combinations.

Parameters

sections (List[Section]) – sections to request the results for, or None for all sections (default: all sections).
cases (List[LoadCombination]) – list of load combinations to request the results for.
chain_index (int) – index of the segment chain to request the results for (default: 1).

Return type

None

Model

class viktor.external.axisvm.Model¶

Can be used to construct an AxisVM model, which can be used as input of AxisVMAnalysis.

Objects are created/modified through the methods on their respective interface (see the properties below for all available interfaces). The following basic actions can be performed on all interfaces (example: node interface):

cast to list, indexing and slicing:

nodes = list(model.nodes)  # List[Node]
node2 = model.nodes[1]  # Node
nodes_2_3 = model.nodes[1:3]  # List[Node]

iteration:

for node in model.nodes:
    print(node.id)

length:
number_of_nodes = len(model.nodes)

containment check:

node_in_model = node in model.nodes  # bool

Example usage:

model = Model()
material = model.materials.add_from_catalog('C12/15', AxisVMMaterial.DesignCode.EURO_CODE)
cross_section = model.cross_sections.create_rectangular(0.01, 0.01)
n1 = model.nodes.create(0, 0, 0)
n2 = model.nodes.create(1, 0, 0)
beam = model.lines.create(n1, n2).define_as_beam(material, cross_section)
model.node_supports.create_relative_to_member(n1, stiffness_x=1e10, stiffness_y=1e10, stiffness_z=1e10,
                                              stiffness_xx=1e10, stiffness_yy=1e10, stiffness_zz=1e10)
load_case = model.load_cases.create()
model.loads.create_beam_self_weight(load_case, beam)
model.results.nodal_displacements([n2])

property references: ReferenceInterface¶

Interface for creating reference points, vectors, axes, planes and angles.

Return type: ReferenceInterface

property materials: MaterialInterface¶

Interface for creating materials.

Return type: MaterialInterface

property nodes: NodeInterface¶

Interface for creating nodes.

Return type: NodeInterface

property cross_sections: CrossSectionInterface¶

Interface for creating cross-sections.

Return type: CrossSectionInterface

property lines: LineInterface¶

Interface for creating lines, beams, etc.

Return type: LineInterface

property domains: DomainInterface¶

Interface for creating domains.

Return type: DomainInterface

property node_supports: NodeSupportInterface¶

Interface for creating node supports.

Return type: NodeSupportInterface

property line_supports: LineSupportInterface¶

Interface for creating line supports.

Return type: LineSupportInterface

property load_cases: LoadCaseInterface¶

Interface for creating load cases.

Return type: LoadCaseInterface

property loads: LoadInterface¶

Interface for creating loads.

Return type: LoadInterface

property load_combinations: LoadCombinationInterface¶

Interface for creating load combinations.

Return type: LoadCombinationInterface

property sections: SectionInterface¶

Interface for creating sections, on which results can be obtained.

Return type: SectionInterface

property results: ResultInterface¶

Interface for requesting results from the worker (only requested results will be returned).

Return type: ResultInterface

viktor.external.axisvm

AxisVMAnalysis​

CircleArc​

Object​

Reference​

Material​

Node​

CrossSection​

Line​

Member​

Domain​

NodeSupport​

LineSupport​

LoadCase​

Load​

LoadCombination​

Section​

ReferenceInterface​

MaterialInterface​

NodeInterface​

CrossSectionInterface​

LineInterface​

DomainInterface​

NodeSupportInterface​

LineSupportInterface​

LoadCaseInterface​

LoadInterface​

LoadCombinationInterface​

SectionInterface​

ResultInterface​

Model​

AxisVMAnalysis

CircleArc

Object

Reference

Material

Node

CrossSection

Line

Member

Domain

NodeSupport

LineSupport

LoadCase

Load

LoadCombination

Section

ReferenceInterface

MaterialInterface

NodeInterface

CrossSectionInterface

LineInterface

DomainInterface

NodeSupportInterface

LineSupportInterface

LoadCaseInterface

LoadInterface

LoadCombinationInterface

SectionInterface

ResultInterface

Model