Skip to main content
Version: 12.7.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: int

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: str

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: 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: 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: str

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

Start node of the line.

Return type

Node

property end_node: viktor.external.axisvm.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, 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: str

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: str

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: str

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

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

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

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

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

Return type

ReferenceInterface

property materials: viktor.external.axisvm.MaterialInterface

Interface for creating materials.

Return type

MaterialInterface

property nodes: viktor.external.axisvm.NodeInterface

Interface for creating nodes.

Return type

NodeInterface

property cross_sections: viktor.external.axisvm.CrossSectionInterface

Interface for creating cross-sections.

Return type

CrossSectionInterface

property lines: viktor.external.axisvm.LineInterface

Interface for creating lines, beams, etc.

Return type

LineInterface

property domains: viktor.external.axisvm.DomainInterface

Interface for creating domains.

Return type

DomainInterface

property node_supports: viktor.external.axisvm.NodeSupportInterface

Interface for creating node supports.

Return type

NodeSupportInterface

property line_supports: viktor.external.axisvm.LineSupportInterface

Interface for creating line supports.

Return type

LineSupportInterface

property load_cases: viktor.external.axisvm.LoadCaseInterface

Interface for creating load cases.

Return type

LoadCaseInterface

property loads: viktor.external.axisvm.LoadInterface

Interface for creating loads.

Return type

LoadInterface

property load_combinations: viktor.external.axisvm.LoadCombinationInterface

Interface for creating load combinations.

Return type

LoadCombinationInterface

property sections: viktor.external.axisvm.SectionInterface

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

Return type

SectionInterface

property results: viktor.external.axisvm.ResultInterface

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

Return type

ResultInterface