Skip to main content
Version: 12.0.0

viktor.external.axisvm

AxisVMAnalysis​

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

Bases: viktor.external.external_program.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 (Optional[BytesIO]) – (optional) BytesIO containing 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()

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

Return type

Optional[BytesIO]

get_result_file()

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

Return type

Optional[BytesIO]

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

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

property id

Object id.

Return type

int

Reference​

class viktor.external.axisvm.Reference(id_)

Bases: viktor.external.axisvm.Object, abc.ABC

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

Material​

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

Bases: viktor.external.axisvm.Object

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

class DesignCode(value)

Bases: enum.Enum

National design code.

OTHER: viktor.external.axisvm.Material.DesignCode = 0
HUNGARIAN_MSZ: viktor.external.axisvm.Material.DesignCode = 1
EURO_CODE: viktor.external.axisvm.Material.DesignCode = 2
ROMANIAN_STAS: viktor.external.axisvm.Material.DesignCode = 4
DUTCH_NEN: viktor.external.axisvm.Material.DesignCode = 5
GERMAN_DIN1045_1: viktor.external.axisvm.Material.DesignCode = 6
SWISS_SIA26X: viktor.external.axisvm.Material.DesignCode = 7
EURO_CODE_GER: viktor.external.axisvm.Material.DesignCode = 8
ITALIAN: viktor.external.axisvm.Material.DesignCode = 9
EURO_CODE_AUSTRIAN: viktor.external.axisvm.Material.DesignCode = 10
EURO_CODE_UK: viktor.external.axisvm.Material.DesignCode = 11
EURO_CODE_NL: viktor.external.axisvm.Material.DesignCode = 12
EURO_CODE_FIN: viktor.external.axisvm.Material.DesignCode = 13
EURO_CODE_RO: viktor.external.axisvm.Material.DesignCode = 14
EURO_CODE_HU: viktor.external.axisvm.Material.DesignCode = 15
EURO_CODE_CZ: viktor.external.axisvm.Material.DesignCode = 16
EURO_CODE_B: viktor.external.axisvm.Material.DesignCode = 17
EURO_CODE_PL: viktor.external.axisvm.Material.DesignCode = 18
EURO_CODE_DK: viktor.external.axisvm.Material.DesignCode = 19
EURO_CODE_S: viktor.external.axisvm.Material.DesignCode = 20
US: viktor.external.axisvm.Material.DesignCode = 21
CA_NBCC: viktor.external.axisvm.Material.DesignCode = 22
CA_ONTARIO: viktor.external.axisvm.Material.DesignCode = 23
CA_BRIDGE: viktor.external.axisvm.Material.DesignCode = 24
EURO_CODE_SK: viktor.external.axisvm.Material.DesignCode = 25
property name

Name of the material.

Return type

str

Node​

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

Bases: viktor.external.axisvm.Object

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

property x

X-coordinate.

Return type

float

property y

Y-coordinate.

Return type

float

property z

Z-coordinate.

Return type

float

CrossSection​

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

Bases: viktor.external.axisvm.Object

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

class Process(value)

Bases: enum.Enum

Manufacturing process.

OTHER: viktor.external.axisvm.CrossSection.Process = 0
ROLLED: viktor.external.axisvm.CrossSection.Process = 1
WELDED: viktor.external.axisvm.CrossSection.Process = 2
COLD_FORMED: viktor.external.axisvm.CrossSection.Process = 3
property name

Name of the cross-section.

Return type

str

Line​

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

Bases: viktor.external.axisvm.Object

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

property start_node

Start node of the line.

Return type

Node

property end_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: viktor.external.axisvm.Object

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

Domain​

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

Bases: viktor.external.axisvm.Object

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

class SurfaceType(value)

Bases: enum.Enum

Finite element type.

HOLE: viktor.external.axisvm.Domain.SurfaceType = 0
MEMBRANE_STRESS: viktor.external.axisvm.Domain.SurfaceType = 1
MEMBRANE_STRAIN: viktor.external.axisvm.Domain.SurfaceType = 2
PLATE: viktor.external.axisvm.Domain.SurfaceType = 3
SHELL: viktor.external.axisvm.Domain.SurfaceType = 4
class MeshType(value)

Bases: enum.Enum

Contour division method.

ADAPTIVE: viktor.external.axisvm.Domain.MeshType = 0
UNIFORM: viktor.external.axisvm.Domain.MeshType = 1
class MeshGeometry(value)

Bases: enum.Enum

Mesh geometry type.

TRIANGLE: viktor.external.axisvm.Domain.MeshGeometry = 0
QUAD: viktor.external.axisvm.Domain.MeshGeometry = 1
MIXED: viktor.external.axisvm.Domain.MeshGeometry = 2
class EccentricityType(value)

Bases: enum.Enum

Type of eccentricity.

CONSTANT: viktor.external.axisvm.Domain.EccentricityType = 1
ONE_WAY: viktor.external.axisvm.Domain.EccentricityType = 2
TWO_WAY: viktor.external.axisvm.Domain.EccentricityType = 3
TOP_ALIGNED: viktor.external.axisvm.Domain.EccentricityType = 4
BOTTOM_ALIGNED: viktor.external.axisvm.Domain.EccentricityType = 5
generate_mesh(mesh_geometry, mesh_size, *, mesh_type=<MeshType.UNIFORM: 1>, 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: viktor.external.axisvm.Object

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

LineSupport​

class viktor.external.axisvm.LineSupport(id_)

Bases: viktor.external.axisvm.Object

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

class NonLinearity(value)

Bases: enum.Enum

Type of non-linear behavior.

LINEAR: viktor.external.axisvm.LineSupport.NonLinearity = 0
TENSION_ONLY: viktor.external.axisvm.LineSupport.NonLinearity = 1
COMPRESSION_ONLY: viktor.external.axisvm.LineSupport.NonLinearity = 2

LoadCase​

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

Bases: viktor.external.axisvm.Object

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

property name

Name of the load case.

Return type

str

Load​

class viktor.external.axisvm.Load(id_)

Bases: viktor.external.axisvm.Object

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

class DistributionType(value)

Bases: enum.Enum

An enumeration.

GLOBAL: viktor.external.axisvm.Load.DistributionType = 0
LOCAL: viktor.external.axisvm.Load.DistributionType = 1
PROJECTED: viktor.external.axisvm.Load.DistributionType = 2
class SurfaceDistributionType(value)

Bases: enum.Enum

An enumeration.

SURFACE: viktor.external.axisvm.Load.SurfaceDistributionType = 0
PROJECTED: viktor.external.axisvm.Load.SurfaceDistributionType = 1
class System(value)

Bases: enum.Enum

An enumeration.

GLOBAL: viktor.external.axisvm.Load.System = 0
LOCAL: viktor.external.axisvm.Load.System = 1
REFERENCE: viktor.external.axisvm.Load.System = 2
class Axis(value)

Bases: enum.Enum

An enumeration.

X: viktor.external.axisvm.Load.Axis = 0
Y: viktor.external.axisvm.Load.Axis = 1
Z: viktor.external.axisvm.Load.Axis = 2
XX: viktor.external.axisvm.Load.Axis = 3
YY: viktor.external.axisvm.Load.Axis = 4
ZZ: viktor.external.axisvm.Load.Axis = 5

LoadCombination​

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

Bases: viktor.external.axisvm.Object

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

class Type(value)

Bases: enum.Enum

An enumeration.

OTHER: viktor.external.axisvm.LoadCombination.Type = 0
SLS_1: viktor.external.axisvm.LoadCombination.Type = 1
SLS_CHAR: viktor.external.axisvm.LoadCombination.Type = 1
SLS_2: viktor.external.axisvm.LoadCombination.Type = 2
SLS_FREQ: viktor.external.axisvm.LoadCombination.Type = 2
SLS_3: viktor.external.axisvm.LoadCombination.Type = 3
SLS_QUASI: viktor.external.axisvm.LoadCombination.Type = 3
ULS_1: viktor.external.axisvm.LoadCombination.Type = 4
ULS: viktor.external.axisvm.LoadCombination.Type = 4
ULS_2: viktor.external.axisvm.LoadCombination.Type = 5
ULS_SEISMIC: viktor.external.axisvm.LoadCombination.Type = 5
ULS_3: viktor.external.axisvm.LoadCombination.Type = 6
ULS_EXCEPTIONAL: viktor.external.axisvm.LoadCombination.Type = 6
ULS_ALL: viktor.external.axisvm.LoadCombination.Type = 7
ULS_AB: viktor.external.axisvm.LoadCombination.Type = 8
ULS_A: viktor.external.axisvm.LoadCombination.Type = 9
ULS_B: viktor.external.axisvm.LoadCombination.Type = 10
ULS_ALL_AB: viktor.external.axisvm.LoadCombination.Type = 11
ULS_A1: viktor.external.axisvm.LoadCombination.Type = 12
ULS_A2: viktor.external.axisvm.LoadCombination.Type = 13
ULS_A3: viktor.external.axisvm.LoadCombination.Type = 14
ULS_A4: viktor.external.axisvm.LoadCombination.Type = 15
ULS_A5: viktor.external.axisvm.LoadCombination.Type = 16
ULS_A6: viktor.external.axisvm.LoadCombination.Type = 17
ULS_A7: viktor.external.axisvm.LoadCombination.Type = 18
ULS_A8: viktor.external.axisvm.LoadCombination.Type = 19
property name

Name of the load case.

Return type

str

Section​

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

Bases: viktor.external.axisvm.Object

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

property name

Name of the section.

Return type

str

ReferenceInterface​

class viktor.external.axisvm.ReferenceInterface

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

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

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

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: 0>, 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

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

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: 1>, 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)

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: 0>, non_linearity_y=<NonLinearity.LINEAR: 0>, non_linearity_z=<NonLinearity.LINEAR: 0>, non_linearity_xx=<NonLinearity.LINEAR: 0>, non_linearity_yy=<NonLinearity.LINEAR: 0>, non_linearity_zz=<NonLinearity.LINEAR: 0>)

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

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: 0>, non_linearity_y=<NonLinearity.LINEAR: 0>, non_linearity_z=<NonLinearity.LINEAR: 0>, 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

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

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: 0>, 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: 0>, system=<System.GLOBAL: 0>)

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

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

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

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

Return type

ReferenceInterface

property materials

Interface for creating materials.

Return type

MaterialInterface

property nodes

Interface for creating nodes.

Return type

NodeInterface

property cross_sections

Interface for creating cross-sections.

Return type

CrossSectionInterface

property lines

Interface for creating lines, beams, etc.

Return type

LineInterface

property domains

Interface for creating domains.

Return type

DomainInterface

property node_supports

Interface for creating node supports.

Return type

NodeSupportInterface

property line_supports

Interface for creating line supports.

Return type

LineSupportInterface

property load_cases

Interface for creating load cases.

Return type

LoadCaseInterface

property loads

Interface for creating loads.

Return type

LoadInterface

property load_combinations

Interface for creating load combinations.

Return type

LoadCombinationInterface

property sections

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

Return type

SectionInterface

property results

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

Return type

ResultInterface