ACT APIs For Mechanical Guide

ANSYS ACT APIs for Mechanical Guide
ANSYS, Inc. Release 19.0

Southpointe January 2018
2600 ANSYS Drive
Canonsburg, PA 15317 ANSYS, Inc. and
[email protected] ANSYS Europe,
Ltd. are UL
http://www.ansys.com registered ISO
(T) 724-746-3304 9001: 2008
(F) 724-514-9494 companies.
Copyright and Trademark Information
© 2017 ANSYS, Inc. Unauthorized use, distribution or duplication is prohibited.
ANSYS, ANSYS Workbench, AUTODYN, CFX, FLUENT and any and all ANSYS, Inc. brand, product, service and feature
names, logos and slogans are registered trademarks or trademarks of ANSYS, Inc. or its subsidiaries located in the
United States or other countries. ICEM CFD is a trademark used by ANSYS, Inc. under license. CFX is a trademark
of Sony Corporation in Japan. All other brand, product, service and feature names or trademarks are the property
of their respective owners. FLEXlm and FLEXnet are trademarks of Flexera Software LLC.
Disclaimer Notice
THIS ANSYS SOFTWARE PRODUCT AND PROGRAM DOCUMENTATION INCLUDE TRADE SECRETS AND ARE CONFID-
ENTIAL AND PROPRIETARY PRODUCTS OF ANSYS, INC., ITS SUBSIDIARIES, OR LICENSORS. The software products
and documentation are furnished by ANSYS, Inc., its subsidiaries, or affiliates under a software license agreement
that contains provisions concerning non-disclosure, copying, length and nature of use, compliance with exporting
laws, warranties, disclaimers, limitations of liability, and remedies, and other provisions. The software products
and documentation may be used, disclosed, transferred, or copied only in accordance with the terms and conditions
of that software license agreement.
ANSYS, Inc. and ANSYS Europe, Ltd. are UL registered ISO 9001: 2008 companies.
U.S. Government Rights
For U.S. Government users, except as specifically granted by the ANSYS, Inc. software license agreement, the use,
duplication, or disclosure by the United States Government is subject to restrictions stated in the ANSYS, Inc.
software license agreement and FAR 12.212 (for non-DOD licenses).
Third-Party Software
See the legal information in the product help files for the complete Legal Notice for ANSYS proprietary software
and third-party software. If you are unable to access the Legal Notice, contact ANSYS, Inc.
Published in the U.S.A.

Table of Contents
ACT API Introduction .................................................................................................................................. 1
Object Access .............................................................................................................................................. 3
Property Types ....................................................................................................................................... 3
Tree Objects ........................................................................................................................................... 4
Model Objects ........................................................................................................................................ 6
Accessing and Manipulating the Geometry Object .......................................................................... 6
Accessing and Manipulating the Mesh Object ................................................................................... 7
Accessing and Manipulating the Connections Object ................................................................... 7
Accessing and Manipulating the Analysis Object .......................................................................... 8
Object Traversal ...................................................................................................................................... 9
Traversing the Geometry .................................................................................................................. 9
Traversing the Mesh ........................................................................................................................ 11
Traversing Results ........................................................................................................................... 12
Boundary Conditions ................................................................................................................................ 15
Input and Output Variables ................................................................................................................... 15
Variable Definition Types ...................................................................................................................... 15
Setting Input Loading Data Definitions ................................................................................................. 16
Setting Variable Definition Types ........................................................................................................... 17
Creating a Displacement and Verifying Its Variable Definition Types ................................................. 17
Changing the Y Component from Free to Discrete and Verifying ...................................................... 18
Changing the Y Component Back to Free and Verifying .................................................................... 19
Setting Discrete Values for Variables ...................................................................................................... 20
Getting and Setting Discrete Values for an Input Variable ................................................................. 20
Getting and Setting Discrete Values for an Output Variable .............................................................. 22
Adding a Load ...................................................................................................................................... 23
Extracting Min-Max Tabular Data for a Boundary Condition ................................................................... 25
Worksheets ............................................................................................................................................... 27
Creating and Populating Named Selection Worksheets .......................................................................... 27
Creating the Named Selection Worksheet ....................................................................................... 27
Adding New Rows to the Named Selection Worksheet ..................................................................... 27
Adding Rows to Existing Mesh Order Worksheets .................................................................................. 29
Displaying the Mesh Worksheet ..................................................................................................... 30
Specifying the Mesh Worksheet and Named Selections ................................................................... 31
Adding New Rows in the Mesh Worksheet ....................................................................................... 31
Meshing the Named Selections ....................................................................................................... 32
Using Additional Commands .......................................................................................................... 33
Accessing Layered Section Worksheets .................................................................................................. 34
Displaying the Layered Section Worksheet ..................................................................................... 34
Getting the Layered Section Worksheet and Its Properties ............................................................... 34
Getting and Displaying the Material Property .................................................................................. 34
Getting and Displaying the Thickness Property ................................................................................ 35
Getting and Displaying the Angle Property ..................................................................................... 35
Setting and Displaying the Thickness Property ................................................................................ 35
Setting and Displaying the Angle Property ...................................................................................... 35
Accessing Bushing Joint Worksheets ..................................................................................................... 35
Displaying the Bushing Joint Worksheet ......................................................................................... 35
Getting the Bushing Joint Worksheet and Its Properties ................................................................... 36
Getting the Value for a Specified Unit .............................................................................................. 36
Graphical Views ........................................................................................................................................ 37
Getting the Data Object ModelViewManager ........................................................................................ 37
Release 19.0 - © ANSYS, Inc. All rights reserved. - Contains proprietary and confidential information
of ANSYS, Inc. and its subsidiaries and affiliates. iii
ACT APIs for Mechanical Guide
Setting the View ................................................................................................................................... 37

Creating a View .................................................................................................................................... 38
Applying a View .................................................................................................................................... 38
Renaming a View .................................................................................................................................. 39
Deleting a View .................................................................................................................................... 39
Rotating a View .................................................................................................................................... 39
Saving a View ....................................................................................................................................... 40
Saving an Object .................................................................................................................................. 40
Exporting an Object .............................................................................................................................. 41
Exporting a Saved View List .................................................................................................................. 41
Importing a Saved View List .................................................................................................................. 41
Results ...................................................................................................................................................... 43
Other APIs ................................................................................................................................................. 45
Mechanical Interface and Toolbar Manipulation .................................................................................... 45
Command Snippets .............................................................................................................................. 45
iv of ANSYS, Inc. and its subsidiaries and affiliates.
ACT API Introduction
The ACT API (Application Programming Interface) provides access to the native functionality of ANSYS
Mechanical. Using APIs, you can access all objects in the Mechanical tree (Project, Model, and Ana-
lysis). With APIs, you can write scripts to not only manipulate existing objects and their properties
but also create new ones.
Note
When you create an object, Mechanical initializes its property values in the Details window
to the same default values used when you add an object via standard mouse-click operations.
Some properties, such as scoping or the mass of a point mass, can be invalid until you enter
a value.
Other ANSYS guides provides related information in which you might be interested:
• For an introduction to writing scripts for Mechanical, see the Scripting in Mechanical Quick Start Guide.
• For descriptions of all ACT API objects, methods, and properties, see the ANSYS ACT API Reference Guide.
• For information on how to use ACT to create apps (extensions) that customize and automate ANSYS
products, see the ANSYS ACT Developer's Guide.
• For ACT usage, customization, and automation information specific to Mechanical, see the ANSYS ACT
Customization Guide for Mechanical.
of ANSYS, Inc. and its subsidiaries and affiliates. 1
2 of ANSYS, Inc. and its subsidiaries and affiliates.
Object Access
Using the ACT API, you can programmatically navigate the Mechanical tree to access objects. The root
node of the tree is ExtAPI.DataModel.Project.
Each tree node has children that you can access by calling the property Children. This returns all
child nodes in the project.
You can also call nested objects, such as Model, Geometry, Mesh, or Solution, to access all instances
of a given object or tree level.
Mesh = ExtAPI.DataModel.Project.Model.Mesh
Connection = ExtAPI.DataModel.Project.Model.Children[3]
Property Types
Each object in the tree has its own set of properties. Descriptions and examples of supported property
types follow:
Quantity: A unit-based value typically related to a physical quantity.
Example:
my_object.ElementSize = Quantity("0.1 [m]")
Numerical Value (float and integer): A property, such as Relevance or Rate, expecting a numerical
value. No unit is specified for this number.
Example:
my_object.TetraGrowthRate = 2
Boolean: A property expecting a True or False value.
Example:
my_object.WriteICEMCFDFiles = True
Geometry Scoping: A property whose value is one or more geometric entities. In this case, you must:
1. Create selection information and specify the IDs of the entities that you want to manipulate.
2. Assign this list of IDs to location or source geometry properties.
Example:
my_selection = ExtAPI.SelectionManager.CreateSelectionInfo(SelectionTypeEnum.GeometryEntities)
my_selection.Ids= [28,25]
My_object.Location = my_selection
Object Access
Tree Objects
The API Ansys.ACT.Automation.Mechanical.Tree provides access to data contained within
the Mechanical tree.
To access the object Tree, you use ExtAPI.DataModel.Tree. The following table provides a
sampling of the APIs available for querying the tree for contained objects. Some usage examples appear
after the table. For a comprehensive list of API members, see the ANSYS ACT API Reference Guide.
Member Description
ActiveObjects Lists all selected objects. Read-only.
AllObjects Lists all of the objects available in the tree.
Read-only.
GetObjectsByName Lists all objects that match the specified name.
GetObjectsByType Lists all objects that match the specified type.
To do so, use the method GetObjectsBy-

Type and pass the type (such as Force) as
an argument. The whole namespace of the
type must be specified.
GetPathToFirstActiveObject Shows the full statement that must be typed
to get the selected object.
Refresh Refreshes the tree.
In the ACT Console, you enter commands to query the tree for contained objects.
To list all objects selected in the tree:

ExtAPI.DataModel.Tree.ActiveObjects
To list all objects available in the tree:

ExtAPI.DataModel.Tree.AllObjects
Tree Objects
To access objects by type:

ExtAPI.DataModel.Tree.GetObjectsByType(Ansys.ACT.Mechanical.BoundaryConditions.Force)
To show the command to get the selected object, type:

ExtAPI.DataModel.Tree.GetPathToFirstActiveObject()
Note
Refreshing the tree can cause performance issues when executing a script that adds many
objects, such as in a loop. To prevent a refresh until the loop completes, use the object
Transaction() as shown in this sample code:
with Transaction():
for i in range(5):
ExtAPI.DataModel.Project.AddComment()
Object Access
Model Objects
In the Mechanical tree, you can access and manipulate model objects. The following topics describe
the objects Geometry, Mesh, Connections, and Analysis:
Accessing and Manipulating the Geometry Object
Accessing and Manipulating the Mesh Object
Accessing and Manipulating the Connections Object
Accessing and Manipulating the Analysis Object
Accessing and Manipulating the Geometry Object

The Geometry object provides you with direct access to the model's geometry information.
To access the Geometry object:

geometry = ExtAPI.DataModel.Project.Model.Geometry
The Geometry object exposes several convenient methods to define new child objects. For example,
you can add a point mass to the Geometry object by calling the method AddPointMass.
point_mass = geometry.AddPointMass()
Child Geometry objects often require a valid location assignment. You can satisfy this requirement by
creating a new selection and setting the property Location:
my_selection.Ids = [22]
point_mass.Location = my_selection
Each child object exposes a variety of important properties. For the point mass created above, a subset
of accessible properties includes:
point_mass.Mass = Quantity("12 [kg]")
point_mass.MassMomentOfInertiaX = Quantity("1.1 [kg m m]")
point_mass.MassMomentOfInertiaY = Quantity("1.2 [kg m m]")
point_mass.MassMomentOfInertiaZ = Quantity("1.3 [kg m m]")
point_mass.Behavior = LoadBehavior.Coupled
point_mass.PinballRegion = Quantity("0.2 [m]")
Combining the three previous actions, the geometry now contains a fully described point mass.
Model Objects
You can export the Geometry object to an STL (STereoLithography) file, which is the most commonly
used file format in 3D printing. The following commands get the project model object and geometry
object and then export the geometry object to an STL file.
mymodel = ExtAPI.DataModel.Project.Model
geo = mymodel.Geometry
geo.ExportToSTL("C:\Temp\geoasstl.stl")
The result is the creation of a geometry file (geoasst1.stl) to the fully qualified directory path
(C:\Temp).
Accessing and Manipulating the Mesh Object

The Mesh object provides you with direct access to the model's mesh information.
To access the Mesh object:

mesh = ExtAPI.DataModel.Project.Model.Mesh
The Mesh object exposes several convenient methods to create new meshing controls. For example,
you can create a meshing control that applies a patch-independent algorithm to the mesh by calling
the method AddAutomaticMethod.
mesh_method = mesh.AddAutomaticMethod()
Child Mesh objects often require a valid location assignment. You can satisfy this requirement by cre-
ating a new selection and setting the property Location:
my_selection.Ids = [16]
mesh_method.Location = my_selection
Each child object exposes a variety of important properties. For the meshing control created above, a
subset of accessible properties includes:
mesh_method.Method = MethodType.AllTriAllTet
mesh_method.Algorithm = MeshMethodAlgorithm.PatchIndependent
mesh_method.MaximumElementSize = Quantity("0.05 [m]")
mesh_method.FeatureAngle = Quantity("12.000000000000002 [degree]")
mesh_method.MeshBasedDefeaturing = True
mesh_method.DefeaturingTolerance = Quantity("0.0001 [m]")
mesh_method.MinimumSizeLimit = Quantity("0.001 [m]")
mesh_method.NumberOfCellsAcrossGap = 1
mesh_method.CurvatureNormalAngle = Quantity("36 [degree]")
mesh_method.SmoothTransition = True
mesh_method.TetraGrowthRate = 1
Accessing and Manipulating the Connections Object

The Connections object provides you with direct access to the model's connection information.
To access the Connections object:

connection = ExtAPI.DataModel.Project.Model.Connections
The Connections object exposes several convenient methods for adding connections. For example,
you can set a frictionless contact region and add a beam:
contact_region = connection.Children[0].Children[0]
contact_region.ContactType = ContactType.Frictionless
Object Access
beam = connection.AddBeam()
Child Connections objects often require a valid location assignment. You can satisfy this requirement
by creating a new selection and setting the appropriate property. For a beam, you set the properties
ReferenceLocation and MobileLocation:
reference_scoping = ExtAPI.SelectionManager.CreateSelectionInfo(SelectionTypeEnum.GeometryEntities)
reference_scoping.Ids = [110]
beam.ReferenceLocation = reference_scoping
mobile_scoping = ExtAPI.SelectionManager.CreateSelectionInfo(SelectionTypeEnum.GeometryEntities)
mobile_scoping.Ids = [38]
beam.MobileLocation = mobile_scoping
Each child object exposes a variety of important properties. For the frictionless contact and beam created
above, a subset of accessible properties includes:
beam.ReferenceBehavior = LoadBehavior.Deformable
beam.ReferencePinballRegion = Quantity("0.001 [m]")
beam.Radius = Quantity("0.005 [m]")
beam.MobileZCoordinate = Quantity("6.5E-03 [m]")
beam.MobilePinballRegion = Quantity("0.001 [m]")
Accessing and Manipulating the Analysis Object

The Analysis object provides you with direct access to the model's analysis information.
To access the first Analysis object in the tree and its settings:
analysis1 = ExtAPI.DataModel.Project.Model.Analyses[0]
analysis_settings = analysis1.AnalysisSettings
The Analysis object exposes several convenient methods for manipulating a specific analysis. For
example, you can add a pre-condition, loads, and a fixed support:
bolt = analysis1.AddBoltPretension()
pressure = analysis1.AddPressure()
force = analysis1.AddForce()
support = analysis1.AddFixedSupport()
Child Analysis objects often require a valid location assignment. You can satisfy this requirement by
creating a selection object and setting the locations. For example, the sample code below sets the
properties Location for the loads and boundary conditions created on the analysis:
pressure_scoping = ExtAPI.SelectionManager.CreateSelectionInfo(SelectionTypeEnum.GeometryEntities)
pressure_scoping.Ids = [220]
pressure.Location = pressure_scoping
force_scoping = ExtAPI.SelectionManager.CreateSelectionInfo(SelectionTypeEnum.GeometryEntities)
force_scoping.Ids = [219]
force.Location = force_scoping
Each child object exposes a variety of important properties. For the loads and boundary conditions
created above, a subset of accessible properties includes:
bolt.SetDefineBy(1, BoltLoadDefineBy.Load) # Change definition for step #1.
bolt.Preload.Output.SetDiscreteValue(0, Quantity("15 [N]")) # Change preload value for step #1.
pressure.Magnitude.Output.Formula = '10*time' # To use a formula
pressure.Magnitude.Output.DiscreteValues=[Quantity('6 [Pa]')] # To use a direct value
force.Magnitude.Output.DiscreteValues=[Quantity('11.3 [N]'), Quantity('12.85 [N]')]
Object Traversal
Object Traversal
You can query the Mechanical tree to determine the connectivity of entities. The following topics describe
how to traverse the objects Geometry, Mesh, and Results:
Traversing the Geometry
Traversing the Mesh
Traversing Results
Note
• The sample code in this section is taken from the supplied extension TraverseExtension.
You can download the package of extension examples from the developer help panel for the
ACT Start Page.
• For comprehensive information on interfaces and properties, see the ANSYS ACT API Reference
Guide.
Traversing the Geometry

The API for geometry data is organized to match the underlying hierarchical data model. For example,
it is possible to query for the faces upon which an edge is defined by using the property Faces exposed
by the edge interface.
The basic hierarchy of the geometry is:

- Geometry
- Assembly
- Part
- Body
- Shell
- Face
- Edge
- Vertex
You can traverse geometry data using the IronPython function traversegeometry(). In the sample
code that follows, an object of type IGeoData is obtained from the object Analysis using the
property GeoData. The object GeoData is then used to query for a list of IGeoAssembly objects
by calling the property Assembly. For each of the IGeoAssembly objects in the returned list, the
property Parts is called and a list of IGeoPart objects is returned. This pattern is repeated through
the hierarchy of the geometry down to the vertices of each edge.
def traversegeometry(analysis):
now = datetime.datetime.now()
outFile = SetUserOutput(analysis, "SolutionDetails.log")
f = open(outFile,'a')
f.write("*.*.*.*.*.*.*.*\n")
f.write(str(now)+"\n")
# --- IGeometry Interface
# +++ Properties and Methods
# +++ Assemblies
# +++ CellFromRefId
# +++ SelectedRefIds
geometry = analysis.GeoData
assemblies = geometry.Assemblies
assemblies_count = assemblies.Count
# --- IGeoAssembly Interface
# +++ Name
Object Access
# +++ Parts
for assembly in assemblies:
assembly_name = assembly.Name
parts = assembly.Parts
parts_count = parts.Count
# --- IGeoPart Interface
# +++ Name
# +++ Bodies
for part in parts:
part_name = part.Name
bodies = part.Bodies
bodies_count = bodies.Count
# --- IGeoBody Interface
# +++ Name
# +++ Vertices
# +++ Edges
# +++ Faces
# +++ Shells
# +++ Material
for body in bodies:
faces = body.Faces
faces_count = faces.Count
# --- IGeoFace Interface
# +++ Body
# +++ Shell
# +++ Vertices
# +++ Edges
# +++ Loops
# +++ Area
# +++ SurfaceType
# +++ PointAtParam
# +++ PointsAtParams
for face in faces:
edges = face.Edges
edges_count = edges.Count
# --- IGeoEdge Interface
# +++ Faces
# +++ Vertices
# +++ StartVertex
# +++ EndVertex
# +++ Length
# +++ CurveType
# +++ Extents
# +++ IsParamReversed
# +++ ParamAtPoint
# +++ PointAtParam
# +++ PointsAtParams
for edge in edges:
vertices = edge.Vertices
vertices_count = vertices.Count
# --- IGeoVertex Interface
# +++ Edges
# +++ Faces
# +++ Bodies
# +++ X
# +++ Y
# +++ Z
for vertex in vertices:
xcoord = vertex.X
ycoord = vertex.Y
zcoord = vertex.Z
try:
f.write(" Vertex: "+vertex.ToString()+", X = "+xcoord.ToString()+", Y = "+yco
except:
continue
f.close()
return
Object Traversal
Traversing the Mesh

The API for mesh data offers a variety of queries through which the connectivity of mesh entities can
be determined.
traversemesh()
You can traverse mesh data using the IronPython function traversemesh(). In the sample code that
follows, an object of type IMeshData is obtained from the object IAnalysis using the property
MeshData. The mesh object is then used to query for a list of element IDs with the property Elements.
For each of the element IDs in the returned list, the method Element is called and the corresponding
object IElement is returned. This pattern is repeated for all of the nodes for each element. Finally,
the coordinates of the nodes are queried. Comments are included in the content of the function tra-
versemesh() to clarify script functionality.
def traversemesh(analysis):
f.write("*.*.*.*.*.*.*.*\n")
# --- IMesh Interface
# +++ MeshRegion
# +++ Node
# +++ Element
# +++ Nodes
# +++ Elements
# +++ NumNodes
# +++ NumElements
mesh = analysis.MeshData
elementids = mesh.ElementIds
# --- IElement Interface
# +++ Id
# +++ Type
# +++ Nodes
for elementid in elementids:
element = mesh.ElementById(elementid)
nodeids = element.NodeIds
# --- INode Interface
# +++ Id
# +++ X
# +++ Y
# +++ Z
# +++ Elements
for nodeid in nodeids:
node = mesh.NodeById(nodeid)
nodex = node.X
nodey = node.Y
nodez = node.Z
try:
f.write(" Element: "+elementid.ToString()+" Node: "+nodeid.ToString()+", X = "+nodex.ToStrin
except:
continue
f.close()
return
elementcounter()
You can also traverse mesh data using the IronPython function elementcounter() can also be used
to access the mesh data. In the sample code that follows, only the elements of user-selected geometry
entities are considered. First, the script obtains the objects IGeoData and IMeshData. The property
Object Access
CurrentSelection.Ids then queries the IDs of the selected geometry entities using the object
ISelectionMgr.
If no IDs are returned, a message box displays the message Nothing Selected. Otherwise, the
methods GeoEntityById and MeshRegionById obtain the objects IGeoEntity and IMeshRegion
corresponding to each selected entity.
These two objects are used inside the try-except block to query for the type of entity selected and the
number of elements in each entity's mesh. The property Type of the interface IGeoEntity and the
property NumElements of the interface IMeshRegion are used here. The results are displayed in a
message box.
def elementcounter(analysis):
geometry = analysis.GeoData
mesh = analysis.MeshData
selectedids = ExtAPI.SelectionManager.CurrentSelection.Ids
if selectedids.Count == 0:
MessageBox.Show("Nothing Selected!")
else:
for selectedid in selectedids:
entity = geometry.GeoEntityById(selectedid)
meshregion = mesh.MeshRegionById(selectedid)
try:
numelem = meshregion.ElementCount
MessageBox.Show("Entity of type: "+entity.Type.ToString()+
" contains "+numelem.ToString()+
" elements.")
except:
MessageBox.Show("The mesh is empty!")
return
return
Traversing Results
The API for solution allows you to query solution details and even compute new results. In the sample
code that follows, the IronPython function minmaxresults() computes the minimum and maximum
component values of the nodal displacement and the SXX stress component.
The function minmaxresults() begins by instantiating a result reader using the method analys-
is.ResultsData. Results are retrieved relative to the finite element model and queried using either
the elementID (elemental result) or the nodeID (nodal result). The displacement result U is a nodal
result, whereas the stress result S is a result on nodes of the elements. The displacement result stores
a set of component values for each node, where the component names are X, Y, and Z.
The function minmaxresults() first iterates over the nodeIDs to compute the minimum and
maximum values. It then iterates over the elementIDs and the nodes of each element to compute
the minimum and maximum values.
Note
The second loop over the nodes is filtered to the primary nodes of the elements because
stress results are available only on these primary nodes.
Finally, the results are written to the output file.

def minmaxresults(analysis):
Object Traversal
f.write("*.*.*.*.*.*.*.*\n")
#
# Get the element ids
#
meshObj = analysis.MeshData
elementids = meshObj.ElementIds
nodeids = meshObj.NodeIds
#
# Get the results reader
#
reader = analysis.GetResultsData()
reader.CurrentResultSet = int(1)
#
# Get the displacement result object
displacement = reader.GetResult("U")
num = 0
for nodeid in nodeids:
#
# Get the component displacements (X Y Z) for this node
#
dispvals = displacement.GetNodeValues(nodeid)
#
# Determine if the component diplacement (X Y Z) is min or max
#
if num == 0:
maxdispx = dispvals[0]
mindispx = dispvals[0]
maxdispy = dispvals[1]
mindispy = dispvals[1]
maxdispz = dispvals[2]
mindispz = dispvals[2]
num += 1
if dispvals[0] > maxdispx:

maxdispx = dispvals[0]
if dispvals[1] > maxdispy:
maxdispy = dispvals[1]
if dispvals[2] > maxdispz:
maxdispz = dispvals[2]
if dispvals[0] < mindispx:
mindispx = dispvals[0]
if dispvals[1] < mindispy:
mindispy = dispvals[1]
if dispvals[2] < mindispz:
mindispz = dispvals[2]
# Get the stress result object

stress = reader.GetResult("S")
num = 0
for elementid in elementids:
element = meshObj.ElementById(elementid)
#
# Get the SXX stress component
#
stressval = stress.GetElementValues(elementid)
#
# Get the primary node ids for this element
#
nodeids = element.CornerNodeIds
for i in range(nodeids.Count):
#
# Get the SXX stress component at node "nodeid"
#
SXX = stressval[i]
#
# Determine if the SXX stress component is min or max
#
if num == 0:
Object Access
maxsxx = SXX
minsxx = SXX
if SXX > maxsxx:

maxsxx = SXX
if SXX < minsxx:
minsxx = SXX
num += 1
#
# Write the results to the output
#
f.write("Max U,X:Y:Z = "+maxdispx.ToString()+" : "+maxdispy.ToString()+" : "+maxdispz.ToString()+"\n")
f.write("Min U,X:Y:Z = "+mindispx.ToString()+" : "+mindispy.ToString()+" : "+mindispz.ToString()+"\n")
f.write("Max SXX = "+maxsxx.ToString()+"\n")
f.write("Min SXX = "+minsxx.ToString()+"\n")
f.close()
Boundary Conditions
ACT provides an API that enables you to manipulate boundary condition fields and add new loads.
Manipulating boundary conditions fields consists of managing the various time-dependent, space-de-
pendent, or frequency-dependent values of boundary conditions during a simulation. A field has one
or more inputs and a single output.
Mathematically speaking:
output = F(input1, input2, ...)
Where F is the boundary condition field.
As with other types of ACT functionality available in Mechanical, the API-based actions for editing
boundary condition fields mirror the actions that can be performed manually in the Mechanical interface.
With the API, you can:
• Set input loading data definitions, which includes setting discrete input and output values
• Set variable definition types (called modes in Mechanical)
Input and Output Variables

Inputs and outputs are represented by objects of the type Variable. Input variables represent the
various input values over the course of the simulation. Output variables represent the various values
of the boundary conditions with regard to the input values.
For example, assume time is an input variable representing the various time values in seconds and
magnitude is an output variable representing the magnitude of a force over time.
Variable Definition Types

The API enables you to set input and output variables to one of three variable definition types (or
modes):
• Discrete. The variable contains a discontinuous set of values. By default, most variables are initially
defined as discrete.
• Formula. The variable is a continuous function depending on inputs, such as. time*10.
• Free. Determines the selection’s freedom to move along the specified plane. This variable definition
type (mode) is available only for certain boundary conditions such as displacements. It is not available
for force or pressure.
Boundary Conditions
Setting Input Loading Data Definitions

For input variables, each variable definition type (or mode) corresponds to one of the input loading
data definition options available in the Details view in Mechanical. You can determine the loading data
definition options available for a given input by checking the drop-down list in Mechanical.
Input loading data definitions are ranked in terms of complexity:
Complexity Variable Definition Type Input Loading Data Description

Definition
1 Discrete Constant (ramped) Two values, with the first
value always 0.
2 Discrete Constant One value.
(time-stepping)
3 Discrete Tabular Values listed in tabular
format.
4 Formula Function Values generated by the
expression assigned to the
variable.
NA Free NA Indicates that the selection
can move freely along the
specified plane. (A value of 0
indicates that movement is
fully constrained.)
Not supported by all types

of boundary conditions.
When you use the API to define boundary condition fields, ACT automatically opts for the least complex
loading data definition that is applicable to the input. For example, if a given input could be defined
as Constant (ramped) but you execute commands defining it as Tabular, ACT defines the input as
Constant (ramped).
Setting Variable Definition Types

The property Variable.DefinitionType provides both get and set capabilities, enabling you to
set input variables to one of three variable definition types (which also specifies a corresponding input
loading data definition) and then verify the variable type and definition in the ACT Console.
Note
You can also change the variable definition type to Discrete or Free by using the property
Variable.DiscreteValues as described in Setting Discrete Values for Variables (p. 20).
An example follows, consisting of the following steps:

Creating a Displacement and Verifying Its Variable Definition Types
Changing the Y Component from Free to Discrete and Verifying
Changing the Y Component Back to Free and Verifying
Creating a Displacement and Verifying Its Variable Definition Types

You start by creating a displacement:
d=ExtAPI.DataModel.Project.Model.Analyses[0].AddDisplacement()
In Mechanical, you can see that by default, the variable definition types for the displacement’s X, Y, and
Z components are set to Free.
You can verify this by executing the following commands in the ACT Console, one at a time.
Boundary Conditions
d.XComponent.Output.DefinitionType
d.YComponent.Output.DefinitionType
d.ZComponent.Output.DefinitionType
In the following figure, each of the variable’s components has a variable definition type of Free.
Note
Even though the query d.XComponent.Output would produce the same output in the
console when the component is Free, be aware that it returns an instance of the Variable
class. This object is then converted into a string by the console. Appending .Definition-
Type to the query consistently returns the actual enum value, whatever the mode.
Changing the Y Component from Free to Discrete and Verifying

Next, you change the variable definition type for the Y component from Free to Discrete and then
verify the definition type change and the output values in the console:
d.YComponent.Output.DefinitionType =VariableDefinitionType.Discrete
d.YComponent.Output
In the figure that follows, you can see that:
• The Y Component is set to Tabular Data because tabular data is the least complex discrete loading data
definition that is applicable to this input.
• The Tabular Data window is now populated with output values of 0 and 0. You can verify in the console
that the output values are 0 and 0.
• You can verify in the console that the variable definition type is set to Discrete.
Changing the Y Component Back to Free and Verifying

Finally, you change the variable definition type for the Y output from Discrete back to Free and verify
the change in the ACT Console:
d.YComponent.Output.DefinitionType = VariableDefinitionType.Free
In the following figure, you can see that the Y Component is set back to Free and the Tabular Data
window is now empty.
Boundary Conditions
Setting Discrete Values for Variables

The property Variable.DiscreteValues provides both get and set capabilities for both input
and output variables. The behavior of these capabilities depends on whether it is being performed on
an input or an output variable:
Getting and Setting Discrete Values for an Input Variable
Getting and Setting Discrete Values for an Output Variable
Getting and Setting Discrete Values for an Input Variable

Getting Discrete Input Values
You can get the discrete input values for a given input variable. For example, a force in a one-step analysis
looks similar to the following figure by default. The two rows in the Tabular Data window correspond to
the discrete values of the single input variable, with 0s as the start time of the first step and 1s as the end
time of the last step.
Setting Discrete Values for Variables
Note
With a three-step analysis, you would see four values by default: the start time and three
end times (one end time for each step).
Setting Discrete Input Values

You can change discrete values for a given input variable. For example, the following code sample adds
a discrete value, inserting a value of t=0.5s without defining an additional step in the analysis. In the figure
that follows, you can see that:
• There is a new row for t=0.5.
• The output cell for row t=1 has a yellow background. This is because a value has not been set for the
output variable.
Removing Discrete Values

You can also remove a discrete value, deleting a row by defining a shorter list of values for the input variable.
In the figure that follows, you can see that:
• You’ve specified a list with a single value, indicating that the other rows should be removed.
• Although a single row is specified, two rows are still showing in the TabularData window. The value
=0 is actually a repeat of the value in the row above and does not correspond to an actual value stored
for the variable. This is because the tabular data in Mechanical always displays a row for time values that
correspond to step end times.
Boundary Conditions
Getting and Setting Discrete Values for an Output Variable

Output variables are not limited to the Discrete variable definition type, so the behavior when getting
and setting outputs is slightly different from that of inputs.
Getting Discrete Output Values

The following table shows the get behavior for the different variable definition types.
Variable Definition Behavior

Type
Discrete Same as described earlier for getting discrete input values.
Free For C#, the property returns null. For Python, the property returns
None.
Formula The property returns the series of variable values.
Setting Discrete Output Values

The following table shows the set behavior according to the list content provided to the property.
List Content Behavior

None or null The variable is switched to the Free definition type if it is supported by
the boundary condition. Otherwise, an error is issued.
Single quantity The variable is switched to the Constant definition type if supported in
object the interface. Otherwise, Constant (ramped) can be chosen. If neither of
those two types are supported, Tabular Data is the default.
Two quantity The variable is switched to Constant (ramped) if supported in the interface.
objects, with Otherwise, Tabular Data is the default.
the first value
being 0
As many The variable is switched to Tabular Data.
quantity
objects as
discrete values
for the input
variables
Does not fall An error is issued, indicating that you should either:
into any of the
above • Provide the appropriate number of values.
categories
Adding a Load
List Content Behavior

• Change the number of input values first, as the input value count is used to
determine the row count of the tabular data. Output values must then comply
with this number of rows.
The following figure shows a sample message.
Setting Variable Definition Type by Acting on Discrete Values

Because values are interconnected with variable definitions, you can use the property Variable.Dis-
creteValues as an alternate way of switching your variable definition type. To set a variable to a partic-
ular variable type, you set the values that are consistent with that variable type. Examples follow:
• To set an input variable to Tabular Data, assign values in tabular format:

d.XComponent.Output.DiscreteValues = [Quantity("1 [m]"), Quantity("10 [m]")]
• To set a variable to Free, assign None to its DiscreteValues:

d.XComponent.Output.DiscreteValues = None
Adding a Load
You can access the Analysis object for an analysis to add a load. This topic describes a static struc-
tural analysis in which external and internal pressures on a pipe are added and then a force is applied
to a section of the pipe.
To access the static structural analysis:

static_structural = ExtAPI.DataModel.Project.Model.Analyses[0]
To access analysis settings:

analysis_settings = static_structural.AnalysisSettings.NumberOfSteps = 4
To add a bolt and fixed support, setting locations and properties:

bolt = static_structural.AddBoltPretension()
bolt_scoping = ExtAPI.SelectionManager.CreateSelectionInfo(SelectionTypeEnum.GeometryEntities)
bolt_scoping.Ids = [200]
bolt.Location = bolt_scoping
bolt.SetDefineBy(1, BoltLoadDefineBy.Load) # Change definition for step #1.
bolt.Preload.Output.SetDiscreteValue(0, Quantity("15 [N]")) # Change preload value for step #1.
support = static_structural.AddFixedSupport()
support_scoping = ExtAPI.SelectionManager.CreateSelectionInfo(SelectionTypeEnum.GeometryEntities)
support_scoping.Ids = [104]
support.Location = support_scoping
To add the external and internal pressures exerted on the pipe and then apply a force to a section of
the pipe:
Boundary Conditions
pressure = static_structural.AddPressure()
pressure.Magnitude.Output.Formula = '10*time'
pressure = static_structural.AddPressure()
pressure.Magnitude.Output.DiscreteValues=[Quantity('6 [Pa]')]
force = static_structural.AddForce()
force_scoping = ExtAPI.SelectionManager.CreateSelectionInfo(SelectionTypeEnum.GeometryEntities)
force_scoping.Ids = [219]
force.Location = force_scoping
Tabular data is used to apply a vector force to the pipe:

Script execution results in the creation of the property Magnitude for the applied force, with time as
an input variable and a single output variable.
Although tabular data is used to define the property Magnitude, you can also use a constant value or
a time-dependent or space-dependent formula. An example follows of how to use a constant value to
define the property.
force.Magnitude.Output.DiscreteValues=[Quantity('10 [N]')]
Extracting Min-Max Tabular Data for a Boundary Condition
Note
If you use a constant ramped from t=0s to define the force, the first value cannot be "0".
You can also opt to define the property Magnitude with global coordinates instead of a vector:
force.DefineBy = LoadDefineBy.Components
force.ZComponent.Output.DiscreteValues = [Quantity('0 [N]'),Quantity('-9 [N]')]
Extracting Min-Max Tabular Data for a Boundary Condition

From the Analysis object in the Mechanical tree, you can extract minimum and maximum tabular
data for boundary conditions. For example, you can extract minimum and maximum force quantities
from tabular data. The following figure displays tabular data for a force and highlights its minimum and
maximum quantities.
Boundary Conditions
First, get the project model object, analysis object, force object, and tabular data object:
anal = mymodel.Analyses[0]
f2 = anal.Children[2]
f2td = f2.Magnitude.Output
Next, get the tuple containing the minimum and maximum force quantities and then display these
quantities:
mnmxf2 = f2td.MinMaxDiscreteValues
mnmxf2
Given the above tabular data, the following results display:
(0 [lbf], 300 [lbf])
The variable mnxf2 is a tuple (pair) of quantities. Each element in the tuple can be gotten by using
the tuple's properties Item1 and Item2.
To get and display only the minimum force quantity:

mnv = mnmxf2.Item1
mnv
(0 [lbf])
To get and display only the maximum force quantity:

mxv = mnmxf2.Item2
mxv
(300 [lbf])
Worksheets
You can use the API to automate the creation of worksheets in Mechanical. You can also use the API
to populate worksheets. To accomplish the following tasks, you enter commands in the ACT Console
and execute these commands in Mechanical.
Creating and Populating Named Selection Worksheets
Adding Rows to Existing Mesh Order Worksheets
Accessing Layered Section Worksheets
Accessing Bushing Joint Worksheets
Creating and Populating Named Selection Worksheets

This section describes how to use the API to create a named selection worksheet and populate it. It
assumes that the scoping method for your named selection is already set to Worksheet.
ACT supports all available actions for named selection worksheets, as described in Specifying Named
Selections Using Worksheet Criteria in the ANSYS Mechanical User’s Guide. This example focuses on the
Add Row action to add new geometric entities to a named selection.
Creating the Named Selection Worksheet

To create a named selection worksheet, you execute these commands:
model = ExtAPI.DataModel.Project.Model
sel = model.AddNamedSelection()
sel.Name = "Pipe"
selws = ExtAPI.SelectionManager.CreateSelectionInfo(SelectionTypeEnum.WorksheetSpecific)
sel.Location = selws
pipews = sel.Location
This sample code creates the named selection object, renames it Pipe, and creates the worksheet for
your named selection.
Adding New Rows to the Named Selection Worksheet

Data in the named selection worksheet defines the criteria based on geometric or meshing entities.
Each row of the worksheet performs a calculation for the specified criteria.
Worksheets
The command AddRow adds worksheet rows according to the standard behavior of the Add option in
Mechanical named selection worksheets. It adds the information defined in the current row to inform-
ation in the previous row, provided that the Entity Type is the same for both rows.
To add the first row in your worksheet:

pipews.AddRow()
pipews.SetEntityType(0,NamedSelectionWorksheetEntityType.Body)
pipews.SetCriterion(0,NamedSelectionWorksheetCriterion.Size)
pipews.SetOperator(0,NamedSelectionWorksheetOperator.GreaterThan)
pipews.SetValue(0,3.8e-5)
pipews.Generate()
This example uses set methods to define a Body with a Size value greater than 3.8e-5.
The method Generate generates the body. After executing this method, the pipe body is selected in
the Graphics view. In the Details view, the property Total Selection is set to 1 Body.
Next, you define and generate another body:
pipews.AddRow()
pipews.SetEntityType(1,NamedSelectionWorksheetEntityType.Body)
pipews.SetCriterion(1,NamedSelectionWorksheetCriterion.Size)
pipews.SetOperator(1,NamedSelectionWorksheetOperator.LessThan)
pipews.SetValue(1,8e-6)
pipews.Generate()
In this row, set methods define a Body with a Distance value less than 3.8e-6. When there are no locally
defined coordinate systems, you do not need to set the Coordinate System value. It is set to Global
Coordinate System by default.
After executing the method Generate, the bolt body is now selected in the Graphics view, along
with the pipe body. In the Details view, the property Total Selection is set to 2 Bodies.

This section describes how to use the API to add rows to an existing mesh worksheet, specifying the
order in which meshing steps are performed in Mechanical.
Worksheets
ACT supports most of the functionality available for mesh worksheets, which is described in Using the
Mesh Worksheet to Create a Selective Meshing History in the ANSYS Meshing User’s Guide. The following
exceptions apply:
• The named selections must have Entity Type set to Body. Other entity types are not supported.
• The Start Recording and Stop Recording buttons are not supported.
This section assumes that you have already defined two or more named selections in Mechanical. In
your sample static structural analysis, you’ve defined three named selections, as shown in the following
figure.
Displaying the Mesh Worksheet

To display the mesh worksheet, perform the following steps:
1. In the tree, select the node Mesh.
2. Click the Worksheet toolbar button.
The empty worksheet is displayed in the Worksheet tab.
Specifying the Mesh Worksheet and Named Selections

Next, you define variables for the mesh worksheet and the named selections to use in the worksheet
rows:
msh = model.Mesh
mws = msh.Worksheet
nsels = model.NamedSelections
ns1 = nsels.Children[0]
Adding New Rows in the Mesh Worksheet

Finally, you add new rows to the mesh worksheet. Each row in the worksheet corresponds to a step in
the meshing sequence.
To add the first row to your worksheet, you execute these commands:
mws.AddRow()
mws.SetNamedSelection(0,ns1)
mws.SetActiveState(0,True)
• The command AddRow adds an empty row.
• The command SetNamedSelection sets Named Selection to your named selection object ns1.
• The command SetActiveState sets Active State at the row index. This enables the row, as indicated
by the check mark in the left column.
The following figure shows the mesh worksheet after the execution of these commands.
Worksheets
Next, you add rows for your other two named selections, ns2 and ns3. For ns3, you use the command
SetNamedSelectionID to set the named selection.
mws.AddRow()
mws.SetNamedSelection(1,ns2)
mws.AddRow()
mws.SetNamedSelectionId(2,ns3.Id)
The following figure shows the mesh worksheet after the two new rows have been added.
Meshing the Named Selections

When you check the Graphics tab, you can see that no mesh has been generated yet. To generate the
mesh for the named selections in the mesh worksheet, execute the following command:
mws.GenerateMesh()
When you execute this command, the steps are processed one by one in the order specified by the
worksheet. For each step, the bodies identified by the named selection are meshed using the meshing
controls applied to them. By watching the mesh generation in the Graphics tab, you can see the order
in which each body is meshed.
Using Additional Commands

Clear the Generated Mesh
To clear the generated mesh, execute the following command:
mws.ClearGenerateMesh()
Delete a Row
To delete a single row, execute the following command:
Worksheets
void DeleteRow(int index)
Delete All Rows

To delete all rows, execute the following command:
mws.DeleteAllRows()
Get Row Count

To display the row count in the ACT Console command history, execute the following command:
mws.RowCount
Accessing Layered Section Worksheets

This section assumes that you've already created a layered section in Mechanical and set Layers to
Worksheet. The following topics describe how to use the API to access the worksheet for a layered
section definition:
Displaying the Layered Section Worksheet
Getting the Layered Section Worksheet and Its Properties
Getting and Displaying the Material Property
Getting and Displaying the Thickness Property
Getting and Displaying the Angle Property
Setting and Displaying the Thickness Property
Setting and Displaying the Angle Property
Displaying the Layered Section Worksheet

To display the layered section worksheet, perform the following steps:
1. In the Project tree, expand the node Geometry node and select the node Layered Section.
2. In the Details view for the layered section, select Layers.
3. To the right of the Worksheet selection for this property, click the right arrow and select Worksheet.
The layered section worksheet is displayed in the Worksheet tab.
Getting the Layered Section Worksheet and Its Properties

To get to the layered section worksheet object:
geo = mymodel.Geometry
ls = geo.Children[1]
lsws = ls.Layers
Getting and Displaying the Material Property

To get and display the material property for layer index 2:
lsmat = lsws.GetMaterial(2)
lsmat
Assume that Structural Steel displays as the material property.
Getting and Displaying the Thickness Property

To get and display the thickness property for layer index 2:
lsthick = lsws.GetThickness(2)
lsthick
Assume that 0.00253999746 displays as the thickness property.
To get and display the thickness property for a different layer index, such as layer index 3:
lsws.GetThickness(3)
Assume that 0.004 displays as the thickness property.
Getting and Displaying the Angle Property

To get and display the angle property for layer index 2:
lsang = lsws.GetAngle(2)
lsang
Assume that 45 displays as the angle property.
Setting and Displaying the Thickness Property

To set the thickness property for layer index 2 to 0.0999999 and display this value:
lsthick = lsws.SetThickness(2,0.0999999)
lsthick = lsws.GetThickness(2)
lsthick
The thickness property then displays as 0.0999999.
Setting and Displaying the Angle Property

To set the angle property for layer index 2 to 22.5 and display this value:
lsang = lsws.SetAngle(2,22.5)
lsang = lsws.GetAngle(2)
lsang
The angle property then displays as 22.5.

A bushing joint worksheet defines stiffness and damping coefficients via symmetric matrices. This section
assumes that you have already created a bushing joint worksheet in Mechanical. The following topics
describe how to use the API to access a bushing joint worksheet:
Displaying the Bushing Joint Worksheet
Getting the Bushing Joint Worksheet and Its Properties
Getting the Value for a Specified Unit
Displaying the Bushing Joint Worksheet

To display the worksheet for a bushing joint, perform the following steps:
Worksheets
1. In the Project tree, expand the node Connections and then the node Joints.
2. Select the node for the bushing joint.
3. To the right of the Worksheet selection for this property, click the right arrow and select Worksheet.
The worksheet for the bushing joint displays in the Worksheet tab. The size of the matrices for stiffness
and damping coefficients are fixed, which means that rows and columns cannot be added or deleted.
Another aspect of these square matrices (6x6) is that they are both symmetric about their main diagonals.
To ensure that these matrices are always symmetric, you cannot enter values into their upper right
corners.
Getting the Bushing Joint Worksheet and Its Properties

To get to the bushing joint worksheet object:
joints = mymodel.Connections.Children[1]
bushing = joints.Children[0]
bws = bushing.BushingWorksheet
Getting the Value for a Specified Unit

The API for a bushing joint worksheet enforces the fixed matrices by limiting the range of indices that
can be specified to set or get the value from a particular cell. The row indices are zero-based.
For example, to get the coefficient for the stiffness per unit Y at row index 1:
bws.GetBushingStiffnessPerUnitY(1)
Assume that 136073.550978543 displays as the stiffness per unit Y.
Now, assume you have entered the following:

bws.GetBushingStiffnessPerUnitZ(0)
The given index of 0 (zero) produces an error because that cell lies above the main diagonal. As indicated
by the error message, the valid range of indices is equal to 2 and less than or equal to 5.
The following figure shows some of the many methods available for getting coefficients for damping
and stiffness.
Graphical Views
The API ModelViewManager allows you to set, create, delete, apply, rename, rotate, save, import,
and export graphical views, providing an alternative to the Manage Views window in Mechanical.
Note
The API ModelViewManager does not export graphical views exactly as they appear in
Mechanical. For example, the exported views exhibit inconsistencies in the zoom and model
orientation. If you want to compare views to see changes in results, export them to PNG files
using the command ExtAPI.Graphics.ExportScreenToImage instead. This command
exports the current view as it appears in Mechanical to a PNG file:
ExtAPI.Graphics.ExportScreenToImage(filePath)
Where filePath is the fully qualified path for the PNG file to create.
Currently, only the PNG file format is supported. The file path must be surrounded by escape
characters. An example follows:
ExtAPI.Graphics.ExportScreenToImage("C:\\Users\\Desktop\\image1.png")
The exported view retains the same orientation, zoom factor, and other graphics rendering
properties as the view in Mechanical.
In situations where exported graphical views do not have to match exactly what is shown in Mechanical,
you can use the API ModelViewManager.
Getting the Data Object ModelViewManager

To get the data object ModelViewManager, you enter the following in the command line of the ACT
Console:
view_manager = ExtAPI.Graphics.ModelViewManager
To get the number of graphical views that are currently defined:

views_count = view_manager.NumberOfViews
Setting the View

Before creating a graphical view, you can set the type of view you want to capture. The following table
provides commands for setting views.
Action Command
Set to ISO view_manager.SetISO-
view View()
Graphical Views
Action Command
Set to Fit view_manager.Set-
view FitView()
Set to Front view_manager.Set-
view FrontView()
Set to Back view_manager.SetBack-
view View()
Set to Right view_manager.Set-
view RightView()
Set to Left view_manager.Se-
view tLeftView()
Set to Top view_man-
view ager.SetTopView()
Set to view_manager.SetBottom-
Bottom view View()
Creating a View
You can create a graphical view from current graphics using either a default name or a specified name.
To create a view using a default name:

view_manager.CreateView
The name assigned to the new view is View followed by the next sequential number.
To create a view using a specified name, where viewName is the name to assign to the new view:
view_manager.CreateView(string viewName)
For example, assume that you want to set the top view and then create a view named Top View:
view_manager.SetTopView()
view_manager.CreateView("Top View")
Applying a View
You can apply a graphical view by specifying its name or index.
To apply a view by specifying its name, where viewLabel is the name of the view to apply:
view_manager.ApplyModelView(string viewLabel)
For example, to apply a view named Fit View:

view_manager.ApplyModelView("Fit View")
To apply a view by specifying its index, where viewIndex is the index of the listed view to apply:
view_manager.ApplyModelView(int viewIndex)
For example, to apply a view with index 1:

view_manager.ApplyModelView(1)
Rotating a View
Renaming a View
To rename a saved graphical view, where viewLabel is the current name of the view to rename and
newLabel is the new name to assign to the view:
view_manager.RenameView(string viewLabel, string newLabel)
For example, assume that a view is currently named View 7 and you want to rename it to ISO View:
view_manager.RenameView("View 7","ISO View")
Deleting a View
You can delete a view by specifying its name or index.
To delete a view by specifying its name, where viewLabel is the name of the view to delete:
DeleteView(string viewLabel)
For example, to delete a view named Left View:

view_manager.DeleteView("Left View")
To delete a view by specifying its index, where viewIndex is the index of the listed view to delete:
DeleteView(int viewIndex)
For example, to delete a view with index 0:

view_manager.DeleteView(0)
Rotating a View
To rotate the active view, where angle is the amount of rotation:
view_manager.RotateView(double angle)
For example, to rotate the active object 45 degrees clockwise:

view_manager.RotateView(45)
Note
For the parameter angle, you enter a positive value to rotate the view clockwise or a neg-
ative value to rotate the view counter-clockwise.
Graphical Views
Saving a View
You can save a graphical view of the entire model as an image file by specifying its name or index. For
all methods, the mode is a string representing the graphics format of the file to which to save the image.
The values that can be entered for mode are "PNG", "JPG", "TIF", "BMP", and "EPS".
Note
For commands that use the parameter folder, an empty string ("") for this parameter defaults
to the project user files. This is a null operation if the specified folder does not exist.
To save a view specified by name as an image to the project user files, where viewLabel is the name
of the view to save and mode is the graphics format for the image file:
view_manager.CaptureModelView(string viewLabel, string mode)
For example, to save a view named Bottom View to a TIF file to the project user files:
view_manager.CaptureModelView("Bottom View", "TIF")
To save a view specified by name as an image to a specified folder, where viewLabel is the name of
the view to save, mode is the graphics format for the image file, and folder is the name of the folder
in which to save the file:
view_manager.CaptureModelView(string viewLabel, string mode, string folder)
For example, to save a view named Right View to a JPG file to D:\My_Projects\Views:
view_manager.CaptureModelView("Right View", "JPG", "D:\My_Projects\Views")
To save a view specified by index as an image to a specified folder, where index is the index of the
view to save, mode is the graphics format for the image file, and folder is the name of the folder in
which to save the file:
view_manager.CaptureModelView(index, string mode, string folder)
For example, to save a view with index 0 to a PNG file to the project user files:
view_manager.CaptureModelView(0, "PNG")
Saving an Object
To save an object as an image to a file having the same name as the object, where obj is the object
to save, mode is the graphics format for the image file, and folder is the name of the folder in which
to save the file:
view_manager.CaptureObjectImage(Ansys.ACT.Automation.Mechanical.DataModelObject obj, string mode, string folder)
For example, to save an object named plate to a BMP file to the project user files:
Importing a Saved View List
view_manager.CaptureObjectImage(Ansys.ACT.Automation.Mechanical.DataModelObject "Plate", "BMP")
Note
An empty string ("") for the parameter folder defaults to the project user files. This is
a null operation if the specified folder does not exist.
Exporting an Object
To export the active object to a 3D AVZ file, where avzffilepath is a fully qualified AVZ filepath:
view_manager.Capture3DImage(string avzfilepath)
For example, to export the active object to a file named my_plane.avz to D:\My_Projects\Views:
view_manager.Capture3DImage("D:\My_Projects\Views\my_plane.avz")
Exporting a Saved View List

To export all saved graphical views to an XML file, where viewfilepath is the name of the XML file
to create:
view_manager.ExportModelViews(string viewfilepath)
For example, to export a saved view list named myviews.xml to D:\My_Projects\Views:

view_manager.ExportModelViews("D:\My_Projects\Views\myviews.xml")
Importing a Saved View List

To import a saved view list by specifying a filename, where viewfilepath is the name of the view
(XML file) to import:
view_manager.ImportModelViews(string viewfilepath)
For example, to import a saved view list named allviews.xml that is located in D:\My_Pro-
jects\Views:
view_manager.ImportModelViews("D:\My_Projects\Views\allviews.xml")
Results
In Mechanical, the Solution object contains child objects for analysis results. To access the Solution
object:
solution = ExtAPI.DataModel.Project.Model.Analyses[0].Solution
You can use the ACT API to add custom results to the Solution object. For example, you can add
the result Total Deformation to a static structural analysis and then solve for the minimum and max-
imum total deformation:
total_deformation = solution.AddTotalDeformation()
analysis = ExtAPI.DataModel.Project.Model.Analyses[0]
analysis.Solve(True)
minimum_deformation = total_deformation.Minimum
maximum_deformation = total_deformation.Maximum
It results in a solved analysis indicating the values for the properties Minimum and Maximum for the
result Total Deformation.
Other APIs
The following sections describe other ACT APIs of particular interest:
Mechanical Interface and Toolbar Manipulation
Command Snippets
Mechanical Interface and Toolbar Manipulation

The API UserInterface provides methods to control the ACT-based interface of Mechanical. This
API is available using the following entry point:
ExtAPI.UserInterface
The API UserInterface allows you to hide or gray-out ACT-based features and customize existing
toolbars. It cannot be used to create new items such as toolbars. The API UserInterface provides
access only to existing UI elements.
ExtAPI.UserInterface.Toolbars is a collection of toolbar objects. Each object has fields such

as Name, Caption, Visibility, and child to access entries. Each child has the following properties:
Caption, Enabled, Entries, EntryType, Name, and Visible.
The Boolean fields Visible and Enabled can be set to show or hide so that you can control the
availability of the buttons depending on the current context.
Command Snippets
The API CommandSnippet provides for defining a MAPDL script that you want to invoke during the
preprocessing, solution-solving, or postprocessing phase of your analysis. Use the function AddCom-
mandSnippet() to insert a new child command snippet in the project tree:
sol = ExtAPI.DataModel.Project.Model.Analyses[0].Solution
cs = sol.AddCommandSnippet()
cs.Input = "/COM, New input"
cs.AppendText("\n/POST1")
You can also use ImportTextFile(string) to import content from a text file or use ExportText-
File(string) to export a command snippet to a text file.

ACT APIs For Mechanical Guide

Uploaded by

Copyright:

Available Formats

ACT APIs For Mechanical Guide

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

ACT APIs For Mechanical Guide

Uploaded by

Copyright:

Available Formats

What is the purpose of the document?

What is the purpose of the document?

What APIs are described in the document?

What APIs are described in the document?

ANSYS ACT APIs for Mechanical Guide

ANSYS, Inc. Release 19.0

© 2017 ANSYS, Inc. Unauthorized use, distribution or duplication is prohibited.

U.S. Government Rights

Published in the U.S.A.

Setting the View ................................................................................................................................... 37

Quantity: A unit-based value typically related to a physical quantity.

Boolean: A property expecting a True or False value.

2. Assign this list of IDs to location or source geometry properties.

To do so, use the method GetObjectsBy-

To list all objects selected in the tree:

To list all objects available in the tree:

To access objects by type:

To show the command to get the selected object, type:

Accessing and Manipulating the Geometry Object

To access the Geometry object:

Accessing and Manipulating the Mesh Object

To access the Mesh object:

Accessing and Manipulating the Connections Object

To access the Connections object:

Accessing and Manipulating the Analysis Object

Traversing the Geometry

The basic hierarchy of the geometry is:

Traversing the Mesh

Finally, the results are written to the output file.

if dispvals[0] > maxdispx:

# Get the stress result object

if SXX > maxsxx:

Where F is the boundary condition field.

• Set variable definition types (called modes in Mechanical)

Input and Output Variables

Variable Definition Types

Setting Input Loading Data Definitions

Input loading data definitions are ranked in terms of complexity:

Complexity Variable Definition Type Input Loading Data Description

Not supported by all types

Setting Variable Definition Types

An example follows, consisting of the following steps:

Creating a Displacement and Verifying Its Variable Definition Types

Changing the Y Component from Free to Discrete and Verifying

In the figure that follows, you can see that:

Changing the Y Component Back to Free and Verifying

Setting Discrete Values for Variables

Getting and Setting Discrete Values for an Input Variable

Setting Discrete Input Values

• There is a new row for t=0.5.

Removing Discrete Values

Getting and Setting Discrete Values for an Output Variable

Getting Discrete Output Values

Variable Definition Behavior

Setting Discrete Output Values

List Content Behavior

List Content Behavior

The following figure shows a sample message.

Setting Variable Definition Type by Acting on Discrete Values