Skip to main content
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_results()

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

The format of the returned dictionary is:

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

dict

get_model_file(*, as_file=False)

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

Parameters

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

New in v13.5.0

Return type

Union[BytesIO, File, None]

get_result_file(*, as_file=False)

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

Parameters

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

New in v13.5.0

Return type

Union[BytesIO, File, None]

CircleArc

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

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

Parameters
  • center (Tuple[float, float, float]) – (x, y, z) position [m] of the arc’s center point.

  • normal_vector (Tuple[float, float, float]) – (x, y, z) component [m] of the arc plane’s normal vector.

  • alpha (float) – signed angle [rad]. Positive angle is counterclockwise, from the start point.

Object

class viktor.external.axisvm.Object(id_)

Bases: ABC

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

property id: int

Object id.

Return type

int

Reference

class viktor.external.axisvm.Reference(id_)

Bases: Object, ABC

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

Material

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

Bases: Object

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

class DesignCode(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

National design code.

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

Name of the material.

Return type

str

Node

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

Bases: Object

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

property x: float

X-coordinate.

Return type

float

property y: float

Y-coordinate.

Return type

float

property z: float

Z-coordinate.

Return type

float

CrossSection

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

Bases: Object

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

class Process(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Manufacturing process.

OTHER: Process = 0
ROLLED: Process = 1
WELDED: Process = 2
COLD_FORMED: Process = 3
property name: str

Name of the cross-section.

Return type

str

Line

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

Bases: Object

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

property start_node: Node

Start node of the line.

Return type

Node

property end_node: Node

End node of the line.

Return type

Node

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

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

Parameters
  • material (Material) – material of the beam.

  • css_start (CrossSection) – cross-section at the start node of the beam.

  • css_end (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(n)

Split the line in ‘n’ equal parts.

Parameters

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

Return type

None

Member

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

Bases: Object

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

Domain

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

Bases: Object

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

class SurfaceType(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Finite element type.

HOLE: SurfaceType = 0
MEMBRANE_STRESS: SurfaceType = 1
MEMBRANE_STRAIN: SurfaceType = 2
PLATE: SurfaceType = 3
SHELL: SurfaceType = 4
class MeshType(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Contour division method.

ADAPTIVE: MeshType = 0
UNIFORM: MeshType = 1
class MeshGeometry(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Mesh geometry type.

TRIANGLE: MeshGeometry = 0
QUAD: MeshGeometry = 1
MIXED: MeshGeometry = 2
class EccentricityType(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Type of eccentricity.

CONSTANT: EccentricityType = 1
ONE_WAY: EccentricityType = 2
TWO_WAY: EccentricityType = 3
TOP_ALIGNED: EccentricityType = 4
BOTTOM_ALIGNED: EccentricityType = 5
generate_mesh(mesh_geometry, mesh_size, *, mesh_type=MeshType.UNIFORM, fit_to_point_loads=None, fit_to_line_loads=None, fit_to_surface_loads=None, quad_mesh_quality=2)

Generate a mesh on the domain.

Parameters
  • mesh_geometry (MeshGeometry) – mesh geometry type.

  • mesh_size (float) – average mesh size [m].

  • mesh_type (MeshType) – contour division method (default: uniform).

  • fit_to_point_loads (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

NodeSupport

class viktor.external.axisvm.NodeSupport(id_)

Bases: Object

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

LineSupport

class viktor.external.axisvm.LineSupport(id_)

Bases: Object

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

class NonLinearity(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Type of non-linear behavior.

LINEAR: NonLinearity = 0
TENSION_ONLY: NonLinearity = 1
COMPRESSION_ONLY: NonLinearity = 2

LoadCase

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

Bases: Object

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

property name: str

Name of the load case.

Return type

str

Load

class viktor.external.axisvm.Load(id_)

Bases: Object

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

class DistributionType(value, names=None, *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=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

SURFACE: SurfaceDistributionType = 0
PROJECTED: SurfaceDistributionType = 1
class System(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

GLOBAL: System = 0
LOCAL: System = 1
REFERENCE: System = 2
class Axis(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

X: Axis = 0
Y: Axis = 1
Z: Axis = 2
XX: Axis = 3
YY: Axis = 4
ZZ: Axis = 5

LoadCombination

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

Bases: Object

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

class Type(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

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

Name of the load case.

Return type

str

Section

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

Bases: Object

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

property name: str

Name of the section.

Return type

str

ReferenceInterface

class viktor.external.axisvm.ReferenceInterface

Bases: _Interface

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

create_point(x, y, z)

Create a reference point.

Parameters
  • x (float) – x-position [m].

  • y (float) – y-position [m].

  • z (float) – z-position [m].

Return type

Reference

create_vector(point_1, point_2)

Create a reference vector.

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

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

Return type

Reference

create_axis(point_1, point_2)

Create a reference axis.

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

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

Return type

Reference

create_plane(point_1, point_2, point_3)

Create a reference plane.

Parameters
  • point_1 (Tuple[float, float, float]) – (x, y, z) position [m] of point 1.

  • point_2 (Tuple[float, float, float]) – (x, y, z) position [m] of point 2.

  • point_3 (Tuple[float, float, float]) – (x, y, z) position [m] of point 3.

Return type

Reference

create_angle(angle)

Create a reference angle.

Parameters

angle (float) – angle [rad].

Return type

Reference

MaterialInterface

class viktor.external.axisvm.MaterialInterface

Bases: _Interface

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

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

Create a concrete material according to the Eurocode.

Parameters
  • e_x (float) – Young’s modulus of elasticity [kN/m2] in local x-direction.

  • e_y (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

add_from_catalog(name, national_design_code)

Adds a material from the catalog.

Parameters
  • name (str) – name of the material to be added (must exist in the corresponding national design code).

  • national_design_code (DesignCode) – national design code in which the material with given name resides.

Return type

Material

NodeInterface

class viktor.external.axisvm.NodeInterface

Bases: _Interface

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

create(x, y, z)

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

Parameters
  • x (float) – x-position [m].

  • y (float) – y-position [m].

  • z (float) – z-position [m].

Return type

Node

CrossSectionInterface

class viktor.external.axisvm.CrossSectionInterface

Bases: _Interface

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

create_circular(diameter, *, name=None)

Create a circular cross-section with given diameter.

Parameters
  • diameter (float) – diameter [m] of the cross-section.

  • name (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

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

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

NodeSupportInterface

class viktor.external.axisvm.NodeSupportInterface(lines)

Bases: _Interface

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

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

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

Parameters
  • node (Node) – node to create the support on. Must be an end-point of a member of type beam or rib.

  • stiffness_x (float) – translational stiffness [kN/m] in local x-direction (default = 0.0).

  • stiffness_y (float) – translational stiffness [kN/m] in local y-direction (default = 0.0).

  • stiffness_z (float) – translational stiffness [kN/m] in local z-direction (default = 0.0).

  • stiffness_xx (float) – rotational stiffness [kNm/rad] around the local x-axis (default = 0.0).

  • stiffness_yy (float) – rotational stiffness [kNm/rad] around the local y-axis (default = 0.0).

  • stiffness_zz (float) – rotational stiffness [kNm/rad] around the local z-axis (default = 0.0).

  • resistance_x (float) – translational resistance [kN/m] in local x-direction (default = 0.0).

  • resistance_y (float) – translational resistance [kN/m] in local y-direction (default = 0.0).

  • resistance_z (float) – translational resistance [kN/m] in local z-direction (default = 0.0).

  • resistance_xx (float) – rotational resistance [kNm/m] around the local x-axis (default = 0.0).

  • resistance_yy (float) – rotational resistance [kNm/m] around the local y-axis (default = 0.0).

  • resistance_zz (float) – rotational resistance [kNm/m] around the local z-axis (default = 0.0).

  • non_linearity_x (NonLinearity) – translational non-linear behaviour in local x-direction (default: linear).

  • non_linearity_y (NonLinearity) – translational non-linear behaviour in local y-direction (default: linear).

  • non_linearity_z (NonLinearity) – translational non-linear behaviour in local z-direction (default: linear).

  • non_linearity_xx (NonLinearity) – rotational non-linear behaviour around the local x-axis (default: linear).

  • non_linearity_yy (NonLinearity) – rotational non-linear behaviour around the local y-axis (default: linear).

  • non_linearity_zz (NonLinearity) – rotational non-linear behaviour around the local z-axis (default: linear).

Return type

NodeSupport

LineSupportInterface

class viktor.external.axisvm.LineSupportInterface

Bases: _Interface

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

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

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

Parameters
  • member (Member) – member (beam) to create the line support on.

  • k_x (float) – stiffness [kN/m/m] in the local x-direction.

  • k_y (float) – stiffness [kN/m/m] in the local y-direction.

  • k_z (float) – stiffness [kN/m/m] in the local z-direction.

  • non_linearity_x (NonLinearity) – non-linear behaviour in the local x-direction (default: linear).

  • non_linearity_y (NonLinearity) – non-linear behaviour in the local y-direction (default: linear).

  • non_linearity_z (NonLinearity) – non-linear behaviour in the local z-direction (default: linear).

  • resistance_fx (float) – resistance [kN/m] in the local x-direction (default: 0.0).

  • resistance_fy (float) – resistance [kN/m] in the local y-direction (default: 0.0).

  • resistance_fz (float) – resistance [kN/m] in the local z-direction (default: 0.0).

Return type

LineSupport

LoadCaseInterface

class viktor.external.axisvm.LoadCaseInterface

Bases: _Interface

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

create(name=None)

Create a load case.

Parameters

name (str) – name of the load case (default: auto).

Return type

LoadCase

LoadInterface

class viktor.external.axisvm.LoadInterface

Bases: _Interface

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

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

Create a linear distributed load on a domain.

Parameters
  • load_case (LoadCase) – load case to add the load to.

  • domain (Domain) – domain to create the load on.

  • load (Tuple[float, float, float]) – magnitude of the load at (point_1, point_2, point_3) [kN].

  • component (Axis) – direction of the load (X, Y, Z only).

  • point_1 (Tuple[float, float, float]) – (x, y, z) position [m] of reference point 1.

  • point_2 (Tuple[float, float, float]) – (x, y, z) position [m] of reference point 2.

  • point_3 (Tuple[float, float, float]) – (x, y, z) position [m] of reference point 3.

  • distribution_type (DistributionType) – distribution type (default: GLOBAL).

  • load_on_hole (bool) – apply load on hole (default: False -> loads disappear on holes).

Return type

Load

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

Create a constant distributed load on a domain.

Parameters
  • load_case (LoadCase) – load case to add the load to.

  • domain (Domain) – domain to create the load on.

  • load (Tuple[float, float, float]) – magnitude of the load (x, y, z) [kN].

  • distribution_type (SurfaceDistributionType) – distribution type (default: SURFACE).

  • system (System) – coordinate system (default: GLOBAL).

Return type

Load

create_domain_self_weight(load_case, domain)

Create a self-weight load on a domain.

Parameters
  • load_case (LoadCase) – load case to add the load to.

  • domain (Domain) – domain to create the load on.

Return type

Load

create_beam_self_weight(load_case, member)

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

Parameters
  • load_case (LoadCase) – load case to add the load to.

  • member (Member) – member to create the load on.

Return type

Load

LoadCombinationInterface

class viktor.external.axisvm.LoadCombinationInterface

Bases: _Interface

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

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

Create a load combination from given load cases and factors.

Parameters
  • combination_type (Type) – load combination type.

  • load_case_factors (Dict[LoadCase, float]) – factorized load cases {load_case: factor}.

  • name (str) – name of the load combination (default: auto).

Return type

LoadCombination

SectionInterface

class viktor.external.axisvm.SectionInterface

Bases: _Interface

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

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

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

Parameters
  • start_point (Tuple[float, float, float]) – (x, y, z) position [m] of the section’s start point.

  • end_point (Tuple[float, float, float]) – (x, y, z) position [m] of the section’s end point.

  • normal_vector (Tuple[float, float, float]) – (x, y, z) components [m] of the section plane’s normal vector.

  • name (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 (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

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

section_surface_forces(sections, cases, chain_index=1)

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

Parameters
  • sections (List[Section]) – sections to request the results for, or None for all sections (default: all sections).

  • cases (List[LoadCombination]) – list of load combinations to request the results for.

  • chain_index (int) – index of the segment chain to request the results for (default: 1).

Return type

None

section_surface_stresses(sections, cases, chain_index=1)

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

Parameters
  • sections (List[Section]) – sections to request the results for, or None for all sections (default: all sections).

  • cases (List[LoadCombination]) – list of load combinations to request the results for.

  • chain_index (int) – index of the segment chain to request the results for (default: 1).

Return type

None

Model

class viktor.external.axisvm.Model

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

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

  • cast to list, indexing and slicing:

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

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

    number_of_nodes = len(model.nodes)
    
  • containment check:

    node_in_model = node in model.nodes  # bool
    

Example usage:

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

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

Return type

ReferenceInterface

property materials: MaterialInterface

Interface for creating materials.

Return type

MaterialInterface

property nodes: NodeInterface

Interface for creating nodes.

Return type

NodeInterface

property cross_sections: CrossSectionInterface

Interface for creating cross-sections.

Return type

CrossSectionInterface

property lines: LineInterface

Interface for creating lines, beams, etc.

Return type

LineInterface

property domains: DomainInterface

Interface for creating domains.

Return type

DomainInterface

property node_supports: NodeSupportInterface

Interface for creating node supports.

Return type

NodeSupportInterface

property line_supports: LineSupportInterface

Interface for creating line supports.

Return type

LineSupportInterface

property load_cases: LoadCaseInterface

Interface for creating load cases.

Return type

LoadCaseInterface

property loads: LoadInterface

Interface for creating loads.

Return type

LoadInterface

property load_combinations: LoadCombinationInterface

Interface for creating load combinations.

Return type

LoadCombinationInterface

property sections: SectionInterface

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

Return type

SectionInterface

property results: ResultInterface

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

Return type

ResultInterface