Version: 14

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]) – (optional) report template that is added to AxisVM file

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]

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

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.

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, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Manufacturing process.

COLD_FORMED: Process = 3

OTHER: Process = 0

ROLLED: Process = 1

WELDED: Process = 2

property name: str: Name of the cross-section.

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 (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 (str) – name of the cross-section (must be unique) (default: auto).

Return type:

CrossSection

Domain

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

Bases: Object

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

class EccentricityType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Type of eccentricity.

BOTTOM_ALIGNED: EccentricityType = 5

CONSTANT: EccentricityType = 1

ONE_WAY: EccentricityType = 2

TOP_ALIGNED: EccentricityType = 4

TWO_WAY: EccentricityType = 3

class MeshGeometry(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Mesh geometry type.

MIXED: MeshGeometry = 2

QUAD: MeshGeometry = 1

TRIANGLE: MeshGeometry = 0

class MeshType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Contour division method.

ADAPTIVE: MeshType = 0

UNIFORM: MeshType = 1

class SurfaceType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Finite element type.

HOLE: SurfaceType = 0

MEMBRANE_STRAIN: SurfaceType = 2

MEMBRANE_STRESS: SurfaceType = 1

PLATE: SurfaceType = 3

SHELL: SurfaceType = 4

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 (float) – fit mesh to point loads (default: false).
fit_to_line_loads (float) – fit mesh to line loads (default: false).
fit_to_surface_loads (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 (float) – eccentricity [m] at reference point 1.
p1 (Tuple[float, float, float]) – (x, y, z) position [m] of reference point 1.
ecc_2 (float) – eccentricity [m] at reference point 2.
p2 (Tuple[float, float, float]) – (x, y, z) position [m] of reference point 2.
ecc_3 (float) – eccentricity [m] at reference point 3.
p3 (Tuple[float, float, float]) – (x, y, z) position [m] of reference point 3.

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 (float) – fit mesh to point loads (default: false).
fit_to_line_loads (float) – fit mesh to line loads (default: false).
fit_to_surface_loads (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 (float) – eccentricity [m] at reference point 1.
p1 (Tuple[float, float, float]) – (x, y, z) position [m] of reference point 1.
ecc_2 (float) – eccentricity [m] at reference point 2.
p2 (Tuple[float, float, float]) – (x, y, z) position [m] of reference point 2.
ecc_3 (float) – eccentricity [m] at reference point 3.
p3 (Tuple[float, float, float]) – (x, y, z) position [m] of reference point 3.

Return type:

None

Line

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

Bases: Object

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

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 (CrossSection) – cross-section at the start node of the beam (default: same as css_start).
local_z_reference (Reference) – local z-reference (must be of type vector) (default: auto).

Return type:

Member

property end_node: Node: End node of the line.

split_by_number(n)

Split the line in ‘n’ equal parts.

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

property start_node: Node: Start node of the line.

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 (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 (CrossSection) – cross-section at the start node of the beam (default: same as css_start).
local_z_reference (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

LineSupport

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

Bases: Object

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

class NonLinearity(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Type of non-linear behavior.

COMPRESSION_ONLY: NonLinearity = 2

LINEAR: NonLinearity = 0

TENSION_ONLY: NonLinearity = 1

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

Load

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

Bases: Object

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

class Axis(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

X: Axis = 0

XX: Axis = 3

Y: Axis = 1

YY: Axis = 4

Z: Axis = 2

ZZ: Axis = 5

class DistributionType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

GLOBAL: DistributionType = 0

LOCAL: DistributionType = 1

PROJECTED: DistributionType = 2

class SurfaceDistributionType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

PROJECTED: SurfaceDistributionType = 1

SURFACE: SurfaceDistributionType = 0

class System(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

GLOBAL: System = 0

LOCAL: System = 1

REFERENCE: System = 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.

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 (str) – name of the load case (default: auto).
Return type:: LoadCase

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, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

OTHER: Type = 0

SLS_1: Type = 1

SLS_2: Type = 2

SLS_3: Type = 3

SLS_CHAR: Type = 1

SLS_FREQ: Type = 2

SLS_QUASI: Type = 3

ULS: Type = 4

ULS_1: Type = 4

ULS_2: Type = 5

ULS_3: Type = 6

ULS_A: Type = 9

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

ULS_AB: Type = 8

ULS_ALL: Type = 7

ULS_ALL_AB: Type = 11

ULS_B: Type = 10

ULS_EXCEPTIONAL: Type = 6

ULS_SEISMIC: Type = 5

property name: str: Name of the load case.

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 (str) – name of the load combination (default: auto).

Return type:

LoadCombination

LoadInterface

class viktor.external.axisvm.LoadInterface

Bases: _Interface

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

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

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_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_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

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, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

National design code.

CA_BRIDGE: DesignCode = 24

CA_NBCC: DesignCode = 22

CA_ONTARIO: DesignCode = 23

DUTCH_NEN: DesignCode = 5

EURO_CODE: DesignCode = 2

EURO_CODE_AUSTRIAN: DesignCode = 10

EURO_CODE_B: DesignCode = 17

EURO_CODE_CZ: DesignCode = 16

EURO_CODE_DK: DesignCode = 19

EURO_CODE_FIN: DesignCode = 13

EURO_CODE_GER: DesignCode = 8

EURO_CODE_HU: DesignCode = 15

EURO_CODE_NL: DesignCode = 12

EURO_CODE_PL: DesignCode = 18

EURO_CODE_RO: DesignCode = 14

EURO_CODE_S: DesignCode = 20

EURO_CODE_SK: DesignCode = 25

EURO_CODE_UK: DesignCode = 11

GERMAN_DIN1045_1: DesignCode = 6

HUNGARIAN_MSZ: DesignCode = 1

ITALIAN: DesignCode = 9

OTHER: DesignCode = 0

ROMANIAN_STAS: DesignCode = 4

SWISS_SIA26X: DesignCode = 7

US: DesignCode = 21

property name: str: Name of the material.

MaterialInterface

class viktor.external.axisvm.MaterialInterface

Bases: _Interface

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

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

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 (float) – Young’s modulus of elasticity [kN/m2] in local y-direction (default = e_x).
e_z (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 (float) – Poisson’s ratio [-] in local y-direction (0 <= nu <= 0.5) (default = nu_x).
nu_z (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 (float) – thermal expansion coefficient [1/C] in local y-direction (default = alpha_x).
alpha_z (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 (str) – material code name, as shown in the interface (default: auto).
name (str) – material name, as shown in the interface (default: auto).

Return type:

Material

Member

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

Bases: Object

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

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 cross_sections: CrossSectionInterface: Interface for creating cross-sections.

property domains: DomainInterface: Interface for creating domains.

property line_supports: LineSupportInterface: Interface for creating line supports.

property lines: LineInterface: Interface for creating lines, beams, etc.

property load_cases: LoadCaseInterface: Interface for creating load cases.

property load_combinations: LoadCombinationInterface: Interface for creating load combinations.

property loads: LoadInterface: Interface for creating loads.

property materials: MaterialInterface: Interface for creating materials.

property node_supports: NodeSupportInterface: Interface for creating node supports.

property nodes: NodeInterface: Interface for creating nodes.

property references: ReferenceInterface: Interface for creating reference points, vectors, axes, planes and angles.

property results: ResultInterface: Interface for requesting results from the worker (only requested results will be returned).

property sections: SectionInterface: Interface for creating sections, on which results can be obtained.

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.

property y: float: Y-coordinate.

property z: float: Z-coordinate.

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

NodeSupport

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

Bases: Object

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

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

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.

Reference

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

Bases: Object, ABC

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

ReferenceInterface

class viktor.external.axisvm.ReferenceInterface

Bases: _Interface

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

create_angle(angle)

Create a reference angle.

Parameters:: angle (float) – angle [rad].
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_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

ResultInterface

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

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

Request line forces for all load cases or combinations.

Parameters:

members (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

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

Request nodal displacements for all load cases or combinations.

Parameters:

nodes (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 (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

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

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.

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 (str) – name of the section (default: auto).

Return type:

Section

viktor.external.axisvm

AxisVMAnalysis​

CircleArc​

CrossSection​

CrossSectionInterface​

Domain​

DomainInterface​

Line​

LineInterface​

LineSupport​

LineSupportInterface​

Load​

LoadCase​

LoadCaseInterface​

LoadCombination​

LoadCombinationInterface​

LoadInterface​

Material​

MaterialInterface​

Member​

Model​

Node​

NodeInterface​

NodeSupport​

NodeSupportInterface​

Object​

Reference​

ReferenceInterface​

ResultInterface​

Section​

SectionInterface​

AxisVMAnalysis

CircleArc

CrossSection

CrossSectionInterface

Domain

DomainInterface

Line

LineInterface

LineSupport

LineSupportInterface

Load

LoadCase

LoadCaseInterface

LoadCombination

LoadCombinationInterface

LoadInterface

Material

MaterialInterface

Member

Model

Node

NodeInterface

NodeSupport

NodeSupportInterface

Object

Reference

ReferenceInterface

ResultInterface

Section

SectionInterface