Marc® Python 2016

Tutorial and Reference Manual

Corporate Europe, Middle East, Africa
MSC Software Corporation MSC Software GmbH
4675 MacArthur Court, Suite 900 Am Moosfeld 13
Newport Beach, CA 92660 81829 Munich, Germany
Telephone: (714) 540-8900 Telephone: (49) 89 431 98 70
Toll Free Number: 1 855 672 7638 Email: [email protected]
Email: [email protected]

Japan Asia-Pacific
MSC Software Japan Ltd. MSC Software (S) Pte. Ltd.
Shinjuku First West 8F 100 Beach Road
23-7 Nishi Shinjuku #16-05 Shaw Tower
1-Chome, Shinjuku-Ku Singapore 189702
Tokyo 160-0023, JAPAN Telephone: 65-6272-0082
Telephone: (81) (3)-6911-1200 Email: [email protected]
Email: [email protected]

Worldwide Web
www.mscsoftware.com

User Documentation: Copyright  2016 MSC Software Corporation. All Rights Reserved.
U.S. Patent 9,361,413
This document, and the software described in it, are furnished under license and may be used or copied only in accordance with the
terms of such license. Any reproduction or distribution of this document, in whole or in part, without the prior written authorization of
MSC Software Corporation is strictly prohibited.
MSC Software Corporation reserves the right to make changes in specifications and other information contained in this document
without prior notice. The concepts, methods, and examples presented in this document are for illustrative and educational purposes
only and are not intended to be exhaustive or to apply to any particular engineering problem or design. THIS DOCUMENT IS
PROVIDED ON AN “AS-IS” BASIS AND ALL EXPRESS AND IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, ARE
DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD TO BE LEGALLY INVALID.
MSC Software logo, MSC, MSC Nastran, Adams, Dytran, Marc, Mentat, and Patran are trademarks or registered trademarks of
MSC Software Corporation or its subsidiaries in the United States and/or other countries.
NASTRAN is a registered trademark of NASA. Python is a trademark of the Python Software Foundation. Parasolid is a registered
trademark of Siemens Product Lifecycle Management Software, Inc. All other trademarks are the property of their respective owners.
This software may contain certain third-party software that is protected by copyright and licensed from MSC Software suppliers.
Additional terms and conditions and/or notices may apply for certain third party software. Such additional third party software terms
and conditions and/or notices may be set forth in documentation and/or at http://web.mscsoftware.com/thirdpartysoftware (or
successor website designated by MSC from time to time).
METIS is copyrighted by the regents of the University of Minnesota. MS MPI is developed by Microsoft Corporation. PCGLSS 8.0,
Copyright  1992-2016 Computational Applications and System Integration Inc. All rights reserved. Portions of this software are
owned by Siemens Product Lifecycle Management Software, Inc.  Copyright 2016.
Use, duplication, or disclosure by the U.S. Government is subject to restrictions as set forth in FAR 12.212 (Commercial Computer
Software) and DFARS 227.7202 (Commercial Computer Software and Commercial Computer Software Documentation),
as applicable.

MA*V2016*Z*Z*Z*DC-PYTH
Contents
Marc Python Tutorial and Reference Manual

Contents

Marc Python Tutorial

Preface
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

Organization of this Manual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

Contents of the Chapters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

Documentation Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1 Introduction
Welcome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

The Basics of Using PyMentat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

The Basics of Using PyPost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

A Brief Look at Python Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Python Data Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2 PyMentat: A Simple Example

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

Creating a Simple Python Script for Mentat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

Python Programming Hints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

Running the Script. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

4 Marc Python Tutorial and Reference Manual

3 PyMentat: Obtaining Data from Mentat

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Creating a Simple Python Script for Mentat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

The py_get_int and py_get_float Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

4 PyMentat: Building Complex Geometry

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

Background Information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

5 PyMentat: Adding Model Properties

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

Plate Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

Node and Element IDs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

Submitting the Job . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

6 PyMentat: Processing a Post File

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

Postprocessing Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

Scalar Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

7 PyMentat: Obtaining Model Data

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

Database Properties Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

Contents 5

Set Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

A Sample Script to Extract Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

Set ID’s and Set Names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

8 PyPost: Reading a Post File

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

PyPost Basics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

9 PyPost: Obtaining Element Data

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

Processing Element Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

10 PyPost: Element Tensor Data

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

Processing Element Tensor Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

11 PyMentat: Using the py_connect Method

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

Creating a Simple Python Script for Marc Mentat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

The py_connect Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

Handling Socket Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

6 Marc Python Tutorial and Reference Manual

12 PyPost: Plotting
Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

Charting Script for Mentat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

The Gnuplot Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

The PyOpenGL Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

13 PyMentat: Menu System Lookup Functions

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

Menu System Lookup Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

Integer Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

Double Function. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

String Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

Boolean Function. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

State Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

14 MentatDCOM: Connecting to Mentat using a .NET Module

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

MentatDCOM Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

Running the Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

MentatDCOM and PyMentat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

15 MarcPost: Reading a Post File using a .NET Module

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

MarcPost Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

Running the Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

MarcPost and PyPost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

Contents 7

Marc Python Reference

Introduction
Using the Python Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

Variable Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1 PyMentat References
PyMentat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2 PyPost References
PyPost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

A Arithmetic and Database Functions

Introduction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

Arithmetic Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

Database Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

Utility Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

Post File Database Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

Set Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

Marc Python Tutorial
Marc Python

Marc Python Tutorial

Preface

Preface
10 Marc Python Tutorial

Introduction
The purpose of this manual is to introduce the user to the Python modules. The tutorial covers the basics of the modules
and helps the novice Python user in becoming comfortable in programming with these modules through a number of
examples that display some typical uses of creating and processing a model in various stages. This tutorial is not
intended to be a Python programming manual. The book Programming Python by Mark Lutz should be used for this
purpose. This manual does assume that the Python user is experienced in using Mentat.

Organization of this Manual

This manual is divided into three parts:

Part I introduces the user to the PyMentat module. This module interacts with Mentat to create, modify, and post
process models.
Part II introduces the user to the PyPost module. This module functions independently of Mentat to postprocess
a Marc post file (results file).
Part III introduces the user to more advanced uses of the PyMentat and PyPost modules.

Contents of the Chapters

Introduction provides information on the basics using PyMentat and of Python

programming.
PART I PyMentat Module
PyMentat: A Simple Example describes a basic PyMentat script.
PyMentat: Obtaining Data from Mentat expands on the common features of PyMentat and describes how a
Python script can get data from Mentat.
PyMentat: Building Complex Geometry displays how you can build complex geometry that cannot be done with
procedure files alone.
PyMentat: Adding Model Properties shows how to add boundary conditions, material properties, geometric
properties and job parameters to allow you to perform a complete linear
elastic analysis of a rectangular strip with a series of holes subjected to
compression loading.
PyMentat: Processing a Post File shows how to process a Marc post file.
PyMentat: Sets shows how to write PyMentat scripts to work with SETS.
11
Preface

PART II PyPost Module

PyPost: Reading a Post File introduces the basics of using the PyPost module to obtain post file data
and find the maximum scalar values.
PyPost: Obtaining Element Data shows how to obtain element scalar data from a post file.
PyPost: Element Tensor Data expands on obtaining element data by showing how to obtain element
tensor data from a post file. It also introduces the PyTensor class.
PART III Advanced Discussions
PyMentat: Using the py_connect Method introduces the basics of using the PyMentat module in a client/server
environment.
PyPost: Plotting Post File Data shows some example of using third party modules to plot the results of a
post file.

Documentation Conventions
Listed below are some font and syntax conventions that are used to make the information in this manual easier to
understand:
• Cross-references (Links) are highlighted in Blue.
• Names of buttons that appear on the Mentat screen are in Initial Caps. The command issued will appear in
lower case, such as *add_nodes. Note that the "*" always precedes the command name to instruct Mentat that
a command is being issued.
• Literal user input and program prompts are in courier font.
• Names of processors are indicated in UPPER CASE.
• A carriage return keystroke is indicated by <CR>.
• The left mouse button is indicated by <ML>.
• The middle mouse button is indicated by <MM>.
• The right mouse button is indicated by <MR>.

• The mouse cursor is indicated by < > .

• A filename implies a concatenation of pathname and filename. The pathname may be omitted if the file name
is in your current directory. You will note the path names are specified with the forward slash character "/", as
in examples/python/userguide. For those using Microsoft Windows, you will need to substitute the forward
slashes with the backslash character "\".
Chapter 1: Introduction

1 Introduction

Welcome 13

The Basics of Using PyMentat 13
 The Basics of Using PyPost 15

A Brief Look at Python Programming 16
CHAPTER 1 13
Introduction

Welcome
Welcome to Python – a set of API’s designed to be used by Python scripts to enhance the functionality of Mentat.

The Basics of Using PyMentat

When you select a menu item in Mentat, it does one of two things:
1. You are presented with a new menu screen.
2. A command is issued.
The concept of using the PyMentat module uses Item 2. To build or modify models using the PyMentat module, a
Python script sends a sequence of commands to Mentat. These commands are the same commands that are issued when
you select the appropriate menu item.
For example, if you select the menus:

MAIN
MESH GENERATION
grid ON
nodes ADD

you will see that the command name of *add_nodes is issued in the dialogue area of Mentat. Therefore, if you want
your Python script to add a node, your script should send the command *add_nodes to Mentat.
Unless you are a very experienced Mentat user, you will most likely develop your PyMentat Python script using the
technique outlined in Figure 1-1.
14 Marc Python Tutorial

GENERATE TEST MODEL

RUN py_create.py USING mentat.proc is created

MENTAT.PROC TO CREATE when Mentat is run
INITIAL PYTHON SCRIPT

DEVELOP AND MODIFY Add new commands as

PYTHON SCRIPT needed in the script

TEST PYTHON SCRIPT

Figure 1-1 The Python Script Development Process

To aid in the development of converting the procedure files to Python scripts, the Python script shown in Figure 1-2
can be used to generate the Python code for any given Mentat procedure file. To use the script, run it as follows:
python py_create.py mentat.proc my_script.py
This script simply reads the procedure file and wraps a py_send command around it. You need to edit the resulting
Python script to add PARAMETERS and other variables for conditional processing.
CHAPTER 1 15
Introduction

#!/usr/bin/python
import sys
import string
def main(fnamei, fnameo):
i = open(fnamei,"r")
o = open(fnameo,"w")
o.write("from py_mentat import *\n")
o.write("def main():\n")
for line in i.readlines():
s = string.strip(line)
if s == "":
continue
st = " py_send(\"%s \")\n" % s
o.write(st)
o.write("\n")
o.write("if __name__ == '__main__':\n")
o.write(" main()\n")

if __name__ == "__main__":
main(sys.argv[1],sys.argv[2])

Figure 1-2 A Python Script to Convert a Marc Mentat Procedure File to a Python Script

The Basics of Using PyPost

The PyPost module is used by a Python script to process a Marc post (results) file. It operates independently from
Mentat. The PyPost API provides a set of methods to be used to obtain the scalar, tensor or vector values stored in a
post file.

Function Description
close Closes a currently open post file and frees any allocated memory.
dies Returns the number of dies in the post file.
domains Returns the number of domains stored in the post file.
element Returns the element data for a particular element.
elements Returns the number of elements in the current increment.
element_id Returns the id of a particular element.
element_scalar Returns a list of a particular element scalar data for a particular element.
element_scalars Returns the number of element scalars available.
element_scalar_label Returns the name of a particular element scalar.
element_sequence Returns the index number of a particular element ID.
element_tensor Returns a list of a particular element tensor for a particular element.
element_tensors Returns the number of element tensors available.
16 Marc Python Tutorial

Function Description
element_tensor_label Returns the name of a particular element tensor.
element_vector Returns a list of a particular element vector data for a particular element.
element_vectors Returns the number of element vectors available
element_vector_label Returns the name of a particular element vector.
extrapolation Sets the integration point extrapolation method.
increments Returns the number of increments available in the post file
moveto Move to a specified increment in the post file
node Returns the nodal data for a particular node.
nodes Returns the number of nodes for the current increment.
node_displacement Returns the nodal displacement values for a particular node.
node_displacements Returns a 1 if nodal displacements are present in the post file, 0 otherwise.
node_id Returns the ID of a particular node
node_scalar Returns the value of a particular node scalar for a particular node.
node_scalars Returns the number of node scalars available.
node_scalar_label Returns the name of a particular node scalar.
node_sequence Returns the index number of a particular node ID
node_vector Returns the value of a particular node vector at a particular node.
node_vectors Returns the number of node vectors available.
node_vector_label Returns the name of a particular node vector.
post_open Opens a post file and returns the PyPost object of it.
set Returns the data for a particular set.
sets Returns the number of sets in the post file.
title Returns the title of the post file.

A Brief Look at Python Programming

In order to enhance your understanding of using PyMentat or PyPost, we will introduce you to the basics of
programming with Python.
Python is an interpreted, interactive object-oriented programming language sometimes compared to Perl, Java, and Tcl.
It has interfaces to IP networking, windowing systems, audio, and other technologies. Integrated with Mentat, it
provides a more powerful scripting language than procedure files since it contains conditional logic and looping
statements such as if, while, and for.
CHAPTER 1 17
Introduction

A Python script that will use the PyMentat module needs to import the py_mentat module using the following
syntax:
from py_mentat import *
Similarly, a Python script that will use the PyPost module needs to import the py_post module using the following
syntax
from py_post import *
One of the biggest differences between the Python language and other programming languages is that Python does not
denote blocks of code with reserved words or symbols such as if..then..endif (FORTRAN) or if { ... }
(curly braces in C). Instead, indenting is used for this purpose. For example, the take following block of FORTRAN
code:
if(jtype.eq.49) then
ladt=idt+lofr
endif
The block of FORTRAN code would need to be coded as follows in Python:
if jtype == 49:
ladt=idt+lofr
Python matches the amount of indenting to the block of code. The colon at the end of the if statement denotes that it
is a compound statement. All the lines that are to be in that block of code need to be at the same indent level. The block
of code is ended when the indenting level returns to the level of to the compound statement. The examples in the
following chapters will show you more about the Python syntax.

Python Data Types

When programming in Python, you don’t explicitly declare a variable’s data type. Python determines the data type
by how the variable is used. Python supports the following implied data types:

Basic Data Types

string A character string similar to the char data in C and character in FORTRAN. a string may be specified
using either single or double quotes.
float A floating point number similar to the double data type in C and the real*8 data type in FORTRAN.
integer An integer or fixed point number similar to the long int data type in C and the integer*8 data type in
FORTRAN.

Extended Data Types

List A Python list is essentially a linked list that can be accessed like an array using the square bracket
operators [ ]. The list can be composed of strings, floats, or integers to name a few.
18 Marc Python Tutorial

The material covered in this tutorial is very basic and should be easy to access and understand for the first time Python
user. Once you have worked through the sample sessions in Part II you should feel comfortable enough to do a
complete analysis simply by extrapolating from what you have learned in the example problems.
A multi-dimension list is created by first creating a single dimensional list, and then creating the other dimensions, as
follows (a 3x2 array):
A = [None] * 3
for i in range(3)
A[i] = [None] * 2
Chapter 2: PyMentat: A Simple Example

2 PyMentat: A Simple Example


Chapter Overview 20

Creating a Simple Python Script for Mentat 20
 Python Programming Hints 22

Running the Script 22
20 Marc Python Tutorial

Chapter Overview
In this section, it will be demonstrated how to create a basic Python script that sends commands to Mentat. For this
purpose, a rectangular grid of elements will be created. Upon completion of this chapter, you should have a clearer
understanding of the following areas:
• The basics for a PyMentat script
• How a Python script communicates with Mentat
• Python Menu layout

Creating a Simple Python Script for Mentat

To begin, we will examine a script that creates a simple element grid. This example is named chap2.py and can be
found in the Mentat directory examples/python/tutorial/c02. Note that the first Python statement contains.
1. from py_mentat import *
This statement will import the PyMentat module into the Python script. It must be used in all Python scripts that will
need to access the PyMentat module.
The remaining code that creates the grid is as follows:
2. # Create the node grid
3. def make_nodes(s,t, xs, ys):
4. y= ys
5. z = 0.0
6. delx = 1.0/s
7. dely = 1.0/t
8. for i in range(0,t):
9. x = xs
10. for j in range(0,s):
11. str = "*add_nodes %f %f %f" % (x, y, z)
12. py_send(str)
13. x = x + delx
14. y = y + dely
15. return
16.
CHAPTER 2 21
PyMentat: A Simple Example

17. # Create the element grid

18. def make_elements(n,m):
19. for i in range(1,m): # the "y" dir
20. n1 = (i-1) * (n) + 1
21. n2 = n1 + 1
22. n4 = n1 + (n)
23. n3 = n2 + (n)
24. for j in range(1,n): # the "x" dir
25. str = "*add_elements %d %d %d %d" %
(n1,n2,n3,n4)
26. py_send(str)
27. n1 = n1 + 1
28. n2 = n2 + 1
29. n3 = n3 + 1
30. n4 = n4 + 1
31. return
32.
33. def main():
34. n = 6
35. m = 8
36. xs = -1.0
37. ys = -1.0
38. make_nodes(n,m,xs,ys)
39. make_elements(n,m)
40. return
22 Marc Python Tutorial

Lines 2-15 The make_nodes routine creates a grid of s x t nodes, starting in the lower left-hand corner at the
point (xs, ys, 0.0). The function range is a built-in Python function that builds a Python list of integers.
Note line 11: This is where the Mentat command string for adding a node is composed. The
*add_nodes command is placed in a Python string, along with the x,y,z node coordinates. The
statement uses Python’s % operator. It is used on string objects, and works much like C’s sprintf
function. A %f, %g, or %e designates a floating point number, and a %d designates an integer. The
objects on the right of the % symbol are paired with the conversion codes starting with the first % code
inside the quoted string. The py_send routine is called with the string to send the command string
to Mentat, at which time it runs the command string just as if it was typed in the Mentat dialogue area.
Lines 18-31 The make_elements routine performs the element connectivity of the node grid using the Mentat
command *add_elements. The loop beginning in line 24 builds the elements moving across the
node grid in the X-direction and up the grid in the Y-direction.
Lines 33-40 The main routine sets the size of the grid and the starting position.

Python Programming Hints

In this example, some Python functions (or routines) were created to build the grid. A Python function is defined with
the compound statement def. The syntax is:
def NAME ’(’ [args] ’)’ ’:’
What follows after the colon is the code that comprises the function. The lines of Python code that define the function
must be indented at least one space. To end the function definition, the code is “unindented”.
The range function is used quite often in these examples. When the range function is used, Python builds a “list” of
integers starting at the first value and ending at one less than the last value. For example, the statement:
for i in range(0,5):
is actually executed as
for i in [0,1,2,3,4]:
In the Python script shown, a string is created and sent to Mentat using the py_send routine. The string could also be
built in the calling argument for py_send, as shown below:
py_send("*add_nodes %f %f %f" % (x, y, z))
The command and the floating point values to be passed are specified in the calling argument.

Running the Script

Start Mentat, and from the main screen select the following menu buttons.

MAIN
UTILS
PYTHON

This brings up the Python Menu screen as shown in Figure 2-1.

CHAPTER 2 23
PyMentat: A Simple Example

Figure 2-1 Python Menu Screen

To run the script, select the RUN button. The other menu items in Figure 2-1 will be discussed in a later chapter on
sockets. When the RUN button is selected, the browser window as shown in Figure 2-2 appears.

Figure 2-2 The Python Browser Window

Note the button named RUN AS SEPARATE PROCESS. This will run the script in a separate window and
communicate to Mentat using a BSD socket connection. This item is discussed in a later chapter. In order to use this
option, a Python script would need to use the py_connect routine to complete the socket connection with Mentat.
This will be discussed in the next chapter. Do not select this option for this example. Browse to the
examples/python/c02 directory and select the file chap2.py. Then select OK to run the script.
When the script completes, a mesh is created as shown in Figure 2-3.
24 Marc Python Tutorial

Figure 2-3 Python Menu Screen with a Created Mesh

In the next chapter, we will modify the script to use Mentat PARAMETERS to create a variably sized grid.
Chapter 3: PyMentat: Obtaining Data from Mentat

PyMentat: Obtaining Data from

3 Mentat

Chapter Overview 26
 Creating a Simple Python Script for Mentat 26

The py_get_int and py_get_float Methods 27

Running the Script 28
26 Marc Python Tutorial

Chapter Overview
In this chapter, it will be demonstrated how to use Mentat PARAMETERS in a Python script using the PyMentat
module. It will also be shown how to run a Python script as a separate process. Upon completion of this chapter, you
should have a clearer understanding of the following areas:
• The py_get_int and py_get_float methods

Creating a Simple Python Script for Mentat

To continue with the example discussed in Chapter 2, we will examine a script that creates a simple element grid and
uses Mentat parameters to control the size of the grid. This example is named chap3.py and can be found in the Mentat
directory examples/python/tutorial/c03. The script is as follows:
1. from py_mentat import *
2. # Create the node grid
3. def make_nodes(s, t, xs, ys):
4. y= ys
5. z = 0.0
6. delx = 1.0/s
7. dely = 1.0/t
8. for i in range(0,t):
9. x = xs
10. for j in range(0,s):
11. str = "*add_nodes %f %f %f" % (x, y, z)
12. py_send(str)
13. x = x + delx
14. y = y + dely
15. return
16.
17. # Create the element grid
18. def make_elements(n,m):
19. for i in range(1,m): # the "y" dir
20. n1 = (i-1) * (n) + 1
21. n2 = n1 + 1
22. n4 = n1 + (n)
23. n3 = n2 + (n)
24. for j in range(1,n): # the "x" dir
CHAPTER 3 27
PyMentat: Obtaining Data from Mentat

25. str = "*add_elements %d %d %d %d"

(n1,n2,n3,n4)
26. py_send(str)
27. n1 = n1 + 1
28. n2 = n2 + 1
29. n3 = n3 + 1
30. n4 = n4 + 1
31. return
32.
33. def main():
34. n = py_get_int("x_size")
35. m = py_get_int("y_size")
36. xs = py_get_float("x_start")
37. ys = py_get_float("y_start")
38. make_nodes(n,m,xs,ys)
39. make_elements(n,m)
40.
41. if __name__ == ’__main__’:
42. py_connect("",40007)
43. main()
44. py_disconnect()

Lines 2-31 The make_nodes and make_elements routines are the same as in the previous chapter.
Lines 33-39 The main routine obtains the values for the size of the grid and the starting point from Mentat using
parameters. The py_get_int method evaluates a formula and returns an integer (fixed point) result
similar to the *calculator command. The py_get_float method evaluates a formula and returns a
floating point number. In this case, these methods obtain the values for these parameters.
Lines 41-44 If the script is invoked as a separate process, (such as “python chap3.py”), then the Python interpreter
sets the Python variable __name__ to the string ‘__main__’. If this is the case, then the Python
script should attempt to make a socket connection to Mentat. The py_connect method is discussed
in more detail in a later chapter.

The py_get_int and py_get_float Methods

The py_get_int and py_get_float methods provide access to Mentat PARAMETERS and Arithmetic or
Database functions. Using Mentat parameters is the method to pass variables from Mentat to a PyMentat script. These
variables are obtained through PyMentat by specifying the name of the parameter or function in the string passed to
28 Marc Python Tutorial

the py_get_int or py_get_float method. These parameters may be combined with any of the Arithmetic or
Database functions described in the Marc Python Reference Manual.
When using the py_get_int or py_get_float methods, they must be used on a system of the same byte
architecture. The values are not converted to a machine independent format before being transmitted.

Running the Script

First, start Mentat. Before running this example, some PARAMETERS need to be defined. The values for these
parameters will be obtained by the Python script to control the size and the position of the grid.
Select the following menus:

MAIN
UTILS
PARAMETERS
NEW PARAMETER
x_size
10
y_size
8
x_start
-1.0
y_start
-1.0

Remember to press the carriage <CR> after typing in each of the numbers to create the parameters. The procedure file
chap3.proc may be executed to perform the above commands for you if you wish.
You may also type the *define command in Mentat’s command prompt window to create or edit the parameter. For
example, to create the parameter x_size you would type
*define x_size 10
As in the previous chapter, bring up the Python browser window with the menus:

MAIN
UTILS
PYTHON
RUN

When the script completes, a mesh will be created the same as in the previous chapter.
Chapter 4: PyMentat: Building Complex Geometry

PyMentat: Building Complex

4 Geometry

Chapter Overview 30
 Background Information 30

Running the Script 33
30 Marc Python Tutorial

Chapter Overview
In this chapter, it will be demonstrated how to build more complex geometry using Python. To continue with the
example discussed in Chapter 3, we will examine a script that creates a more complex model. This example uses
Mentat’s user-defined menu to present a simple menu for controlling the model’s properties.
Upon completion of this chapter, you should have a clearer understanding of the following areas:
• Adding points, curves, and lines
• Become more familiar with Python programming

Background Information
A rectangular plate of user defined width and height contains a varying number of holes of user-defined diameter d,
equally spaced by a user-defined distance s. It is desired that the Python script determine how many holes can be placed
in the plate, and center the array of holes in the plate with the distance from any edge to the nearest hole to be at least
the distance s.

d d d

t=.75
height

d d d

d d d

width

Figure 4-1 Plate with varying Number of Holes

CHAPTER 4 31
PyMentat: Building Complex Geometry

This example is named chap4.py and can be found in the Mentat directory examples/python/tutorial/c04. The
following is the Python script:
1. from py_mentat import *
2. def add_plate(xs,ys,width, height):
3. py_send("*set_curve_type line")
4. py_send("*add_points")
5. py_send("%f %f 0" % (xs, ys))
6. py_send("%f %f 0" % (xs+width, ys))
7. py_send("%f %f 0" % (xs+width, ys+height))
8. py_send("%f %f 0" % (xs, ys+height))
9. py_send("*set_curve_type line")
10. py_send("*add_curves")
11. py_send("1 2")
12. py_send("2 3")
13. py_send("3 4")
14. py_send("4 1")
15. py_send("*fill_view")
16. return
17.
18. def build_plate(xstart,ystart,width, height, diameter, spacing):
19. f = diameter+spacing
20. nx = int((width-spacing)/f)
21. ny = int((height-spacing)/f)
22. if (nx < 1 or ny < 1 ):
23. print "Holes are too big!"
24. return 1
25. print "creating hole grid of ",nx, " by ",ny
26.
27. add_plate(xs,ys,width,height)
28. xs = .5 * (width - f * (nx - 1)) + xstart
29. ys = .5 * (height - f * (ny - 1)) + ystart
30. py_send("*set_curve_type circle_cr")
31. py_send("*add_curves")
32. r = diameter / 2
32 Marc Python Tutorial

33. for i in range(0, ny) :

34. y = ys + i * f
35. for j in range(0, nx) :
36. x = xs + j * f
37. py_send("%f %f 0 %f" % (x, y, r))
38. return 0
39.
40. def main():
41. width = py_get_float("width")
42. height = py_get_float("height")
43. diameter = py_get_float("diameter")
44. spacing = py_get_float("spacing")
45. xstart = -width/2
46. ystart = -height/2
47. build_plate(xstart,ystart,width, height, diameter, spacing)
48. return
49.
50. if __name__ == ’__main__’:
51. py_connect("127.0.0.1",40007)
52. main( )

Lines 2-16 The add_plate routine creates the plate using four connected curves. It first generates the end points
of the curve using the *add_points command, and then creates the curves by connecting the points
with the *add_curves commands. In line 15, the *fill_view command is issued to center and
fill the plate properly on the screen.
Lines 18-38 The build_plate routine calculates the number of holes that can be placed in the plate and creates them
in their proper position. The variables nx and ny in lines 20 and 21 are the number of holes to be
placed in the x and y direction, respectively. The Python int function is used to force the values to be
an integer. Once it has been determined that the plate is big enough to contain at least one hole, the
add_plate routine is called in line 27 to create the plate itself. The initial x and y position for the first
hole is calculated in lines 28-29. The loop in lines 38-44 controls the vertical (height) placement, and
the inner loop in lines 35-37 controls the horizontal (width) placement.
Lines 40-48 The main routine obtains the values for the size of the plate, the diameter of the holes, and the spacing
between holes from Mentat. The lower-left corner of the plate is calculated in lines 45-46 so that the
plate has its center at (0,0). The build_plate routine is then called to create the geometry.
Lines 50-52 If run in a separate process, make a socket connection to Mentat.
CHAPTER 4 33
PyMentat: Building Complex Geometry

Running the Script

Start Mentat and use the FILES menu SET DIRECTORY button to specify examples/python/tutorial/c04 as the current
directory. The parameters used in this model may be specified with the USER DEFINED menu HOLES IN PLATE
(Python). Enter the following values for this example:

WIDTH
12.0
HEIGHT
8.0
DIAMETER
.75
SPACING
0.4
MESH SIZE
0.2

Remember to press the carriage return <CR> after typing in the numbers. Note that the MESH SIZE parameter is not
used in this example. When you specify these values, the menu creates these parameters in Mentat, and the values for
these parameters are obtained by the Python script to control the number of holes in the plate. Select the BUILD button
to create the model.
When the script completes, a plate will be created as shown in Figure 4-2.
34 Marc Python Tutorial

Figure 4-2 Resulting Plate with Holes

In the next chapter, we will mesh the plate and add the geometric and material properties, boundary conditions, and
job parameters.
Chapter 5: PyMentat: Adding Model Properties

PyMentat: Adding Model

5 Properties

Chapter Overview 36
 Plate Properties 36

Node and Element IDs 40

Running the Script 41
 Submitting the Job 43
36 Marc Python Tutorial

Chapter Overview
In this chapter, it will be demonstrated how to add properties to the geometry create in the previous chapter.
Upon completion of this chapter, you should have a clearer understanding of the following areas:
• Using the Database functions
• Node and Element IDs

Plate Properties
As shown in Chapter 4, a rectangular plate of user defined width and height contains a varying number of holes of
user-defined diameter d, equally spaced by a distance s specified by the user. The array of holes will be centered in the
plate, with the distance from any edge to the nearest hole to be at least the distance s.
In this chapter, we will update the Python script to apply the properties described in Figure 5-1 to the plate. The material
behavior is linear elastic with Young’s modulus E = 30e6 and Poisson’s ratio  = 0.3. A compression load with
magnitude p = 1000 Lb/in2 will be applied to the top of the plate.

Y
1000 Lb/in2

d d d

t=.75
height

fixed d d d

d d d

width

Figure 5-1 Plate with Varying Number of Holes

CHAPTER 5 37
PyMentat: Adding Model Properties

This example is named chap5.py and can be found in the Mentat directory examples/python/tutorial/c05. The
following Python code has been added to the code shown in the previous chapter:
79. # check if f1 == f2 within tolerance of tol
80. def check_tol(f1, f2, tol):
81. if f1 == f2:
82. return 1
83. if f1 + tol < f2:
84. if f1 - tol > f2:
85. return 1
86. return 0
87.
88. def mesh_plate(width, height, diameter, spacing):
89. py_send("*set_curve_div_type_fix_avgl")
90. l = spacing/2.0
91. py_send("*set_curve_div_avgl %f" % l)
92. py_send("*apply_curve_divisions all_existing")
93. py_send("*dt_planar_trimesh all_existing")
94. return
95.
96. def add_bc(xs,ys,width,height):
97. py_send("*renumber_all")
98. n = py_get_int("nnodes()")
99. # add fixed bc at left edge
100. py_send("*apply_type fixed_displacement")
101. py_send("*apply_dof x")
102. py_send("*apply_dof y")
103. py_send("*apply_dof z")
104.
105. node_list = []
106. for i in range(1,n+1):
107. str = "node_x(%d)" % i
108. f = py_get_float(str)
109. if check_tol(f, xs, .001):
110. node_list.append(i)
38 Marc Python Tutorial

111.
112. py_send("*add_apply_nodes ")
113. for i in range(0,len(node_list)):
114. str = "%d " % node_list[i]
115. py_send(str)
116. py_send(" # ")
117. # add edge load at top
118. py_send("*new_apply")
119. py_send("*apply_type edge_load")
120. py_send("*apply_value p 1000.0 ")
121. py_send("*add_apply_curves 3 #")
122. return
123.
124. def add_matl():
125. py_send("*material_type mechanical:isotropic")
126. py_send("*material_value isotropic:youngs_modulus 3e7 .3")
127. py_send("*add_material_elements all_existing")
128. return
129.
130. def add_job():
131. py_send("*loadcase_type static")
132. py_send("*job_class mechanical")
133. py_send("*job_option dimen:pstress")
134. py_send("*add_post_tensor stress")
135. py_send("*add_post_var von_mises")
136. py_send("*element_type 6 all_existing")
137. py_send("*element_type 6 all_existing")
138. return
139.
140. def add_geom_prop():
141. py_send("*geometry_type mech_planar_pstress ")
142. py_send("*geometry_value thick .75")
143. py_send("*add_geometry_elements all_existing")
144. return
CHAPTER 5 39
PyMentat: Adding Model Properties

145.
146. def main():
147. xs = 0.0
148. ys = 0.0
149. width = py_get_float("width")
150. height = py_get_float("height")
151. diameter = py_get_float("diameter")
152. spacing = py_get_float("spacing")
153. build_plate(xs,ys,width, height, diameter, spacing)
154. mesh_plate(width, height, diameter, spacing)
155. add_bc(xs,ys,width, height)
156. add_matl()
157. add_geom_prop()
158. add_job()
159. py_send("save_as_model chap5.mfd yes")
160. return
161.
162. if __name__ == ’__main__’:
163. py_connect("",40007)
164. main()
165. py_disconnect()
166.

Lines 2-8 The check_tol routine is a convenience function to compare two floating point number for equality
within a certain tolerance.
Lines 10-17 The mesh_plate routine generates a 2-D planar Delaunay triangle mesh. To generate the curve
divisions, the spacing between the holes is used to control the average length of the segments.
Lines 19-46 The add_bc routine creates the boundary conditions for the plate. The left edge of the plate is fixed,
and the top edge of the plate has an edge load. We first obtain the number of nodes using the Database
function nnodes in line 3. In line 11, we renumber all the nodes in the database so that the node index
is the same as the node ID. This will be discussed more in detail later in this chapter. We set the
displacement type to be fixed in lines 6-12. The code in lines 14-20 searches through the entire node
list looking for a node that lies on the left edge of the plate by examining it’s position in the X direction.
If a match is found, we obtain the node ID (which may be different from it’s index position in the
database) and store that in our node_list. In lines 21-25, the command *add_apply_nodes is used
to apply the fixed boundary conditions. We loop through the node_list and send the IDs, and then #
symbol to signal the End List command. Lines 28-31 is where the top edge load is created. Here,
we simply apply the load to the curve at the top of the plate (curve number 3).
40 Marc Python Tutorial

Lines 48-52 The add_matl routine applies the material properties to all the elements of the plate.
Lines 54-61 The add_job routine creates the necessary job parameters.
Lines 63-67 The add_geom_prop routine applies the necessary geometric properties.
Lines 69-83 The main routine is similar to that of Chapter 4, however, the additional routines are called to add the
boundary conditions, the material properties, the geometric properties, and the job parameters.

Node and Element IDs

The Database functions use node and element IDs (similar to labels) as their arguments. In the add_bc routine of our
Python script, we issue the renumber_all command. This command renumbers all of the entities in the model. This
ensures that the index value passed to the database function node_x is the same as that of the loop value. We need to
do this because the entities (nodes in this case) are stored in the database as a linked list as shown in Figure 5-2.

x = -1.0
y = -1.0
z = 0.0
ID = 1

x = 1.0
y = -1.0
z = 0.0
ID = 2

x = 1.0
y = 1.0
z = 0.0
ID = 3

x = -1.0
y = 1.0
z = 0.0
ID = 4

Figure 5-2 A Linked List of Nodes

The linked list of nodes in Figure 5-2 shows a square grid of nodes 1,2,3,4. If node 2 is deleted, then the list would
become 1,3,4 as shown in Figure 5-3.
CHAPTER 5 41
PyMentat: Adding Model Properties

x = -1.0
y = -1.0
z = 0.0
ID = 1

x = 1.0
y = 1.0
z = 0.0
ID = 3

x = -1.0
y = 1.0
z = 0.0
ID = 4

Figure 5-3 A Linked List of Nodes with Node 2 Deleted

If the database function node_id is now called with the value of 2, it returns with 3, since the second item in the list
is node 3. If the command renumber_all is issued, then the nodes will be renumbered to the sequence 1,2,3 and
node_id(2) will return 2.
If we did not issue the renumber_all command, then the code sequence in lines 20-24 would need to be:
for i in range(1,n+1):
str = "node_id(%d)" % i
j = py_get_int(str)
str = "node_x(%d)" % j
f = py_get_float(str)
if check_tol(f, xs, .001):
node_list.append(j)
We want to avoid using the node_id function as much as possible because it needs to search the entire database to
find the node.

Running the Script

You may run the procedure file chap5.proc to set the parameters or you may specify them using the UTIL submenu
PARAMETERS as follows:

UTIL
PARAMETERS
NEW PARAMETER
WIDTH
8.0
HEIGHT
42 Marc Python Tutorial

4.0
DIAMETER
1.0
SPACING
0.5

Remember to press the carriage return <CR> after typing in each of the numbers. Select the BUILD button to create the
model.
When the script completes, a mesh will be created as shown in Figure 5-4.

Figure 5-4 Resulting Mesh with Boundary Conditions Applied

CHAPTER 5 43
PyMentat: Adding Model Properties

Submitting the Job

You may run the job by using the following menus:

MAIN
JOBS
RUN
SUBMIT 1

In the next chapter, we will examine postprocessing using the PyMentat module.
Chapter 6: PyMentat: Processing a Post File

PyMentat: Processing a Post

6 File

Chapter Overview 45
 Postprocessing Basics 45

Scalar Values 49

Running the Script 49
CHAPTER 6 45
PyMentat: Processing a Post File

Chapter Overview
In this chapter, it will be demonstrated how to use the Postprocessing commands of Mentat in a Python script. This
example will use the post file of the example created in the previous chapter.
Upon completion of this chapter, you should have a clearer understanding of the following areas:
• The basics of using PyMentat for Postprocessing
• How to write an efficient PyMentat postprocessing PyMentat script
• Selecting nodes for display

Postprocessing Basics
PyMentat may also be used to postprocess a post file.
In this example, we will obtain all of the nodal scalar values on the post file generated by running the example in the
previous chapter.
This example is named chap6.py and can be found in the Mentat directory examples/python/tutorial/c06. The
following is the Python code:
1. from py_mentat import *
2.
3. def main():
4. py_send("*post_close")
5. py_send("*post_open chap5_job1.t16")
6. py_send("*post_next")
7. py_send("*fill_view")
8. py_send("*post_contour_lines")
9.
10. n = py_get_int("nnodes()") # get number of nodes
11. label = []
12. label.append("Displacement x")
13. label.append("Displacement y")
14. label.append("*External Force x")
15. label.append("External Force y")
16. label.append("Reaction Force x")
17. label.append("Reaction Force y")
18.
19. max_scalars = []
46 Marc Python Tutorial

20. max_nodes = []
21. for i in range(0,len(label)):
22. max_scalars.append(0.0)
23. max_nodes.append(0)
24. str = "*post_value " + label[i]
25. py_send(str)
26.
27. j = 1
28. while j <= n:
29. str = "node_id(%d)" % j
30. n_id = py_get_int(str)
31. str = "post_node_extra(%d)" % n_id
32. flag = py_get_int(str)
33. if flag == 0: # check for valid post node
34. str = "scalar_1(%d)" % n_id
35. f = py_get_float(str)
36. if f < 0.0:
37. f = -f
38. if f > max_scalars[i]
39. max_scalars[i] = f
40. max_nodes[i] = n_id
41. j = j + 1
42.
43. py_send("*draw_legend off")
44. py_send("*unpost_nodes all_existing")
45. py_send("*post_nodes ")
46.
47. print " Label node scalar"
48. print " ------------------------------------------"
49. for i in range(0,len(label)):
50. j = max_nodes[i]
51. str = " %18s %10i %g" % (label[i],
p.py_node_id(j),max_scalars[i])
52. print str
CHAPTER 6 47
PyMentat: Processing a Post File

53. py_send( max_nodes[i] )

54. py_send(" #")
55. py_send("*post_numerics")
56.
57. # Use database functions to find max/min
58. print " "
59. print " Label node scalar"
60. print " ------------------------------------------"
61. for i in range(0,len(label)):
62. str = "*post_value " + label[i]
63. py_send(str)
64. str = "node_id(%d)" % j
65. n_id = py_get_int("scalar_max_node()")
66. str = "scalar_1(%d)" % n_id
67. d = py_get_float(str)
68. n_id2 = py_get_int("scalar_min_node()")
69. str = "scalar_1(%d)" % n_id
70. f = py_get_float(str)
71. if d < -f:
72. d = -f
73. n_id = n_id2
74. str = " %18s %10i %g" % (label[i],n_id, d)
75. print str
76. return
77.
78. if __name__ == '__main__':
79. py_connect('',40007)
80. main()
81. py_disconnect()

Lines 4-7 These statements open the post file and setup some options. We need to do a *post_next in line 6
so that we are at "increment 0" in Marc terminology.
Line 8 We need to tell Mentat that we are working with scalar values, so one of the SCALAR PLOT commands
need to be sent.
48 Marc Python Tutorial

Line 10 This statement will get the number of nodes in the model. Note that this number may change at
different increments due to rezoning.
Lines 11-17 A Python list is used to store the names of the nodal scalars that are in the post file. This is a convenient
way of storing the names for use later. A Python list has an append method, and it is used to add the
desired string to the list. Note that a Python list can be a list of anything, integers, floating points
values, Python dictionaries, or other lists.
Lines 19-20 The max_scalars and max_nodes variables are declared as Python Lists. The index of the list
will be each of the scalars in the post file. The maximum scalar value will be stored in the
max_scalars list. The node associated with the max_scalar value will be stored in the
max_nodes list.
Lines 21 The loop for all of the scalars in our list.
Lines 22-23 We append initial values to our list. Remember that max_scalars and max_nodes are linked lists,
so we must have the item added to the list before we access it.
Lines 24-25 Specify the scalar name to use.
Lines 28 Loop through all the nodes. Note that we use a while loop for this. We had been using the Python
range function; however, for the range function, Python builds a list of all the values in the range. If
we had 100,000 nodes, Python would build a list with that many items.
Lines 29-30 Obtain the node ID for this node.
Lines 31-32 Not all nodes in the post file are visible nodes. Some are nodes used explicitly by Marc to perform
special functions and are considered “extra” nodes. The Database function post_node_extra
returns a zero if a node is not an extra node, one if it is. This check is required to verify that the values
obtained are true post file values at a node.
Lines 33-34 Obtain the scalar value using the Database function scalar_1.
Lines 35-36 We will use only positive values. If it is negative, then change it to positive.
Lines 37-39 Check the current value against the highest value in our list.
Line 43 Turn off the legend.
Lines 44-45 We need to remove all nodes from the post nodes list and then start the *post_nodes selection.
Note that once the *post_nodes selection process has begun, we cannot call any of the py_get
routines.
Line 43 Start the *select_node command.
Lines 47-52 Print out the results for each scalar.
Line 53 Send this node as one of the nodes to select. Note that we use the Python backquote operator which
converts an integer for a float into a string.
Line 54 Send the # symbol to signify End of List.
Line 55 Turn on NUMERICS.
Line 58-76 This section uses the database functions to find the node with the maximum (or minimum) value. It
loops through all the post values in the list, and then calls scalar_max_node and
scalar_min_node to obtain the node number at which the largest and smallest values occur. It
then calls the function scalar_1 to obtain the value associated with that node.
CHAPTER 6 49
PyMentat: Processing a Post File

Scalar Values
Using the PyMentat module for postprocessing is somewhat complex: you have to know what the scalar labels are,
check for valid nodes, etc. The PyPost module avoids this by providing methods to obtain what these items are.

Running the Script

This script runs the same way as in the previous examples. Bring up the Python browser and browse to the Mentat
directory examples/python/tutorial/c06 and run the Python script chap6.py. The output appears as shown in Figure 5-1
for both runs where it searches the node list and using the Database functions.

Label node scalar

-------------------------------------------
Displacement x 53 0.00128282
Displacement y 49 0.00565143
External Force x 0 0
External Force y 50 187.5
Reaction Force x 82 2866.6
Reaction Force y 81 921.814

Figure 5-1 Resulting Output from chap6.py

Figure 5-2 Resulting Post Plot from chap6.py

In the next chapter, we will examine the post file using the Python module PyPost.
Chapter 7: PyMentat: Sets

7 PyMentat: Obtaining Model Data


Chapter Overview 51

Database Properties Basics 51
 Set Basics 52

A Sample Script to Extract Data 52

Running the Script 57
 Set ID’s and Set Names 61
CHAPTER 7 51
PyMentat: Obtaining Model Data

Chapter Overview
In this chapter, it will be demonstrated how to obtain information regarding sets and to how to extract database
properties in a Python script . This example will use a simple model containing various sets and database properties.
Upon completion of this chapter, you should have a clearer understanding of the following areas:
• The basics of sets in Mentat
• How to query set information in a Python script
• How to obtain database properties
• How to obtain element data

Database Properties Basics

Database properties can be obtained using a number of methods that return the data stored in Mentat’s database. Mentat
has functions that supports the following items:

• adapg Global adaptive remeshing criteria.

• apply Boundary condition properties.
• cbody Contact body data.
• ctable Contact table data
• geom Geometric properties.
• icond Initial condition properties.
• material Material properties.
• lcases Loadcase data.
• jobs Job data.

Specific element properties may also be obtained using a number of methods that return the name of the item for each
element. Mentat provides the following element property methods:

• element_cbody Name of contact body that the element belongs.

• element_geom Name of the geometric property that the element belongs.
• element_material Name of the material property that the element belongs.
• element_orient Name of the orientation property that the element belongs.
52 Marc Python Tutorial

Set Basics
The use of sets help to group items together to make it easier to reference them later. Mentat supports the following set
types:

• node The set contains the node IDs of its entries.

• element The set contains the element IDs of its entries.
• point The set contains the point IDs of its entries.
• curve The set contains the curve IDs of its entries.
• surface The set contains the surface IDs of its entries.
• edge The set contains the element IDs and the edge number of its entries.
• face The set contains the element IDs and the face number of its entries.

A number of database functions are available in Mentat to support sets. The list of functions may be found in the Marc
Python Reference Manual, Appendix A, Table A-2.
A Mentat model may contain any number of sets. The database function nsets is used to obtain the number of sets in
a model. Sets are referenced by its set id. The set id is obtained using the database function set_id, which takes an
index number as its only argument. The remaining set functions use the set id to refer to the set; however, Mentat refers
to sets by name. The set name is obtained using the set_name function, and the set type is obtained using the
set_type function.
Each set in turn may contain multiple entries. The number of entries can be obtained using the function
nset_entries. The values for the entries are obtained using the set_entry function, which returns a single
value. If the set type is an edge set or a face set, the second value, the edge or face number, is obtained by calling the
set_edge or set_face function, respectively.

A Sample Script to Extract Data

In this example, we will obtain some database and set information in a simple Mentat model.
This example is named chap7.py and can be found in the Mentat directory examples/python/tutorial/c07. The
following is the Python code:
1. from py_mentat import *
2. def main():
3. py_send("*new_model yes *open_model sets.mfd")
4.
5. m = py_get_int("nsets()")
6. print "Found ",m," sets"
7.
CHAPTER 7 53
PyMentat: Obtaining Model Data

8. for i in range(1,m+1):
9. id = py_get_int("set_id(%d)" % i)
10. sn = py_get_string("set_name(%d)" % id)
11. st = py_get_string("set_type(%d)" % id)
12. n = py_get_int("nset_entries(%d)" % id)
13.
14. if stype not in ("icond","apply","lcase"):
15. print "Set ",sn,"is a ",stype," set with ",n,"entries"
16. for j in range(1,n+1):
17. k = py_get_int("set_entry(%d,%d)" % (id, j))
18. print " entry ",j," is ",k,
19. if (stype == 'face'):
20. l = py_get_int("set_edge(%d,%d)" % (id, j))
21. print " face number ",l
22. elif(stype == 'edge'):
23. l = py_get_int("set_edge(%d,%d)" % (id, j))
24. print " edge number ",l
25. else:
26. print " "
27.
28. print " "
29. m = py_get_int("ncbodys()")
30. print "Found ",m," Contact Bodys"
31. for i in range(1,m+1):
32. sn = py_get_string("cbody_name_index(%d)" % i)
33. id = py_get_int("cbody_id(%s)" % sn)
34. print " Contact Body ", i, " Id ",id, " Name ", sn
35.
36. m = py_get_int("nmaterials()")
37. print "\n Materials ",m
38. for i in range(1,m+1):
39. sn = py_get_string("material_name_index(%d)" % i)
40. st = py_get_string("material_type(%s)" % sn)
54 Marc Python Tutorial

41. p = py_get_float("material_par
(%s,isotropic:youngs_modulus)" % sn)
42. str = " Material %14s Type %19s Young's Mod %g" % (sn,st,p)
43. print str
44. mt = py_get_string("material_opt( %s,plasticity:method)" % sn)
45. st = py_get_string("material_opt( %s,plasticity:yield)" % sn)
46. str = " Plasticity method %9s Yield Surface %s" % (mt, st)
47. print str
48.
49. m = py_get_int("napplys()")
50. print "\n Boundary Conditions ",m
51. for i in range(1,m+1):
52. sn = py_get_string("apply_name_index(%d)" % i)
53. st = py_get_string("apply_type(%s)" % sn)
54. so = py_get_string("apply_opt(%s,dof_values)" % sn)
55. str = " Boundary Cond %14s Type %19s Values by: % s" % (sn,st,so)
56. print str
57.
58. m = py_get_int("ngeoms()")
59. print "\n Geometric Properties ",m
60. for i in range(1,m+1):
61. sn = py_get_string("geom_name_index(%d)" % i)
62. st = py_get_string("geom_type(%s)" % sn)
63. p = py_get_float("geom_par(%s,thick)" % sn)
64. str = " Geometric Prop %12s Type %19s Thick %g" % (sn,st,p)
65. print str
66.
67. m = py_get_int("niconds()")
68. print "\n Initial Conditions ",m
69. for i in range(1,m+1):
70. sn = py_get_string("icond_name_index(%d)" % i)
71. st = py_get_string("icond_type(%s)" % sn)
72. so = py_get_string("icond_opt(%s,dof_values)" % sn)
73. str = " Initial Cond %14s Type %12s Values by: %s" % (sn,st,so)
CHAPTER 7 55
PyMentat: Obtaining Model Data

74. print str

75.
76. print ""
77. sn = py_get_string("material_name()")
78. print " Current material data: ", sn
79. st = py_get_string("material_type(%s)" % sn)
80. print " Type : ", st
81. e = py_get_data( "material:isotropic:youngs_modulus")
82. print " Youngs Modulus : ", e
83. p = py_get_data("material:isotropic:poissons_ratio")
84. print " Poissons Ratio : ", p
85. ys = py_get_data("material:plasticity:yield_stress")
86. print " Yield Stress : ", ys
87.
88. print ""
89. sn = py_get_string("ctable_name()")
90. print " Contact Table ", sn
91. sn = "contact_table:the_mesh:refined_mesh:dist_tol"
92. dt = py_get_data(sn)
93. print " Contact Dist Tol : ", dt
94.
95. print ""
96. sn = py_get_string("geom_name()")
97. print " Current geometry data: ", sn
98. thick = py_get_data("geometry:thick")
99. print " Thickness : ", thick
100.
101. print ""
102. m = py_get_int("nelements()")
103. max_eid = py_get_int("max_element_id( )")
104. print " Elements ", m, " Maximum id ", max_eid
105. for i in range(1,m+1):
106. id = py_get_int("element_id(%d)" % i)
107. print ""
56 Marc Python Tutorial

108. sn = "element_class(%d)" % id
109. e_class = py_get_int(sn)
110. sn = "element_family(%d)" % id
111. e_fam = py_get_int(sn)
112. e_ty = py_get_int(sn)
113. print " Element ", id, " Class ",e_cl," Family ",e_fam,",
Type ",e_ty
114. cbn = py_get_string("element_cbody(%d)" % id)
115. gmn = py_get_string("element_geom(%d)" % id)
116. orn = py_get_string("element_orient(%d)" % id)
117. mtn = py_get_string("element_material(%d)"% id)
118. print " Contact Body : ", cbn
119. print " Geometry Property : ", gmn
120. print " Orientation : ", orn
121. print " Material Property : ", mtn
122.
123. return
124.
125. if __name__ == '__main__':
126. py_connect('',40007)
127. main()
128. py_disconnect()

Lines 3 Open the model to examine the set information.

Lines 5-6 Obtain and print the number of sets found. This uses the nsets Database function.
Line 8 Loop through all the sets in the model. The sets begin at 1.
Line 9 Obtain the set ID. All of the set database functions will use the Set Id to locate the set information.
Line 10 Obtain the set name using the set_name database function.
Line 11 Obtain the set type using the set_type database function.
Line 12 Obtain the number of entries in this set.
Line 14 Ignore the loadcase, boundary condition (apply) and initial condition (icond) set types. These are
associated with the loadcase data.
Line 15 Print the set header information.
Line 16 Loop through all the entries in this set.
Line 17 Using the set_entry database function, obtain each item, and print out the results.
CHAPTER 7 57
PyMentat: Obtaining Model Data

Line 18-26 Depending on the set type, obtain the edge number or the face number if it is an edge or face set.
Line 28-34 Obtain the number of contact bodies. For each contact body, get the contact body name based on its
index, 1 - ncbodys using the cbody_name_index database function. Supplying an index of
0 will return the current contact body name. Also obtained is the contact body index. Note from the
output that the index and ID are not identical.
Line 36-74 In a manner similar to that for contact bodies, obtain the number of materials, boundary conditions,
geometric properties and initial conditions. For each item, obtain the name using the index based
name functions, xxx_name_index. Valid index values are from 1...m, where a value of 0
indicates the current item name. Note that in line 40 the function material_par is used to obtain
a material parameter using a syntax similar to that used for py_get_data as described below.
However, in the xxx_par methods the class token is not used.
Line 76-99 This code displays how to obtain some values of the current material and contact table using the
py_get_data function. The syntax for this function is basically the same that is used in the
command that sets the value. In this example, the value obtained is Young’s modulus. The command
that sets the value is:
*material_value isotropic:youngs_modulus
The argument to the function will use the same parameter to obtain the value, with the first token
specifying the class:
py_get_data(‘material:isotropic:youngs_modulus’)
sn=’contact_table::the_mesh:refined_mesh:dist_tol’)
py_get_data(sn))
This function supports materials (material), contact bodies (contact_body), contact tables
(contact_table), boundary conditions (apply), geometric properties (geometry), global
remeshing (adapg), local adaptivity, (adapt) initial conditions (icond), loadcases (loadcase)
and jobs (job). It provides multi-level data retrieval which is also supported in the function
material_par. However, the py_get_data function only operates on the current item class.
Line 101-121 Obtain specific element information such as its class, type and familty. Also obtain the material,
geometric property, orientation property and contact body in which it belongs.

Running the Script

To run this script, bring up the Python browser and browse to the Mentat directory examples/python/tutorial/c07 and
run the Python script chap7.py. However, do not select the RUN AS SEPARATE PROCESS button since the Python
console/terminal window will exit when it is finished, and the resulting print statements will not be seen.
When the script completes, the output appears as shown in Figures 7-1 and 7-2.
58 Marc Python Tutorial

Found 16 sets
Set TOP is a node set with 2 entries
entry 1 is 3
entry 2 is 4
Set BOTTOM is a node set with 2 entries
entry 1 is 1
entry 2 is 2
Set LITTLE_EL is a element set with 1 entries
entry 1 is 2
Set RIGHT_ELEMENT is a element set with 1 entries
entry 1 is 3
Set RULED_SURF is a surface set with 1 entries
entry 1 is 1
Set BEZIER_CURVE is a curve set with 2 entries
entry 1 is 1
entry 2 is 2
Set EDGES is a edge set with 4 entries
entry 1 is 1 edge number 2
entry 2 is 2 edge number 1
entry 3 is 3 edge number 1
entry 4 is 3 edge number 2

Set FACES is a face set with 2 entries

entry 1 is 4 face number 0
entry 2 is 2 face number 0
Set icond_velo_nodes is a node set with 1 entries
entry 1 is 5
Set icond_mass_nodes is a node set with 4 entries
entry 1 is 17
entry 2 is 18
entry 3 is 19
entry 4 is 20
Set icond_usersub_nodes is a node set with 1 entries
entry 1 is 15
Set apply_usersub_nodes is a node set with 1 entries
entry 1 is 16

Figure 7-1 Set output from chap7.py

The database output is shown in Figure 7-2.

CHAPTER 7 59
PyMentat: Obtaining Model Data

Contact Bodys 4
Contact Body 1 , Id 1 Name surface
Contact Body 2 , Id 2 Name the_mesh
Contact Body 3 , Id 3 Name refined_mesh
Contact Body 4 , Id 5 Name empty_cbody
Materials 2
Material steel Type mechanical/isotropic Young's
Mod 3e+007
Plasticity method default Yield Surface general_plasticity
Material stainless Type mechanical/isotropic Young's
Mod 2.9e+007
Plasticity method chaboche Yield Surface von_mises

Boundary Conditions 3
Boundary Cond apply1 Type point_load Values
by: entered
Boundary Cond apply2 Type point_load Values
by: entered
Boundary Cond apply_usersub Type fixed_displacement Values
by: usersub
Geometric Properties 2
Geometric Prop th_shell Type mech_three_shell Thick
0.7
Geometric Prop membrane Type mech_three_membrane Thick
0.2
Initial Conditions 3
Initial Cond icond_velo Type velocity Values by:
entered
Initial Cond icond_mass Type point_mass Values by:
entered
Initial Cond icond_usersub Type displacement Values by:
usersub

Current material : steel

Type : mechanical/isotropic
Youngs Modulus : 30000000.0
Poissons Ratio : 0.3
Yield Stress : 32000000.0

Contact Table : ctable1

Contact Dist Tol : 0.01
60 Marc Python Tutorial

Current geometry : th_shell

Thickness : 0.7

Contact Table
Contact Dist Tol : 0.01

Elements 4 Maximum id 4

Element 1 Class 4 Family 3 , Type 18

Contact Body : the_mesh

Geometry Property : th_shell
Orientation :
Material Property : steel

Element 2 Class 4 Family 3 , Type 18

Contact Body : refined_mesh
Geometry Property : th_shell
Orientation :
Material Property : steel

Element 3 Class 4 Family 3 , Type 3

Contact Body : the_mesh
Geometry Property : membrane
Orientation :
Material Property : stainless

Element 4 Class 4 Family 3 , Type 3

Contact Body : refined_mesh
Geometry Property : membrane
Orientation :
Material Property : stainless

Loadcase : forge_align , Type static

ArcLength Method : advanced_crisf

Job : forging_analysis , Type mechanical

Follower Force : begin_inc

Figure 7-2 Database output from chap7.py

CHAPTER 7 61
PyMentat: Obtaining Model Data

Set ID’s and Set Names

In most cases, it is desirable to reference sets using their names. However, all of the database functions for sets use the
set id. The following piece of Python code will take a set name and search for the set ID.

def find_set_id(name):
n = py_get_int("nsets()")
for i in range(1,n+1):
id = py_get_int("set_id(%d)" % i)
sname = py_get_string("set_name(%d)" %
id)
if( sname == name):
return id
return -1

Figure 7-3 Python Code to Find the Set ID of a Given Set Name
Chapter 8: PyPost: Reading a Post File

8 PyPost: Reading a Post File


Chapter Overview 63

PyPost Basics 63
 Running the Script 65
CHAPTER 8 63
PyPost: Reading a Post File

Chapter Overview
In this chapter, it will be demonstrated the basics of using PyPost to read a Marc post file. This example will use the
post file of the example created in the previous chapter.
Upon completion of this chapter, you should have a clearer understanding of the following areas:
• The basics of using PyPost
• How to use PyPost to read nodal data

PyPost Basics
In the previous chapter, it was shown how to use PyMentat to post process a post file. The PyMentat module depends
on interacting with Mentat. Sometimes it is more convenient to work in a non-GUI environment, such as an X-Term
window or a Microsoft Windows command prompt window. The PyPost module works in this manner.
PyPost is an API used in a Python script to obtain the results from a Marc post file. The PyPost module contains one
routine that is used to open a post file, post_open. This routine returns a PyPost object. This PyPost object contains
the methods that are used to access various data items in the post file.
When using the PyPost module, you will import the module in the same way as importing the PyMentat module using
the statement:
from py_post import *
To begin accessing a post file, you must call the PyPost routine post_open, such as:
pObj = post_open("chap5_job1.t16")
This statement opens the post file named chap5_job1.t16 and returns a PyPost object, storing it in the variable pObj.
This example is named chap8.py and can be found in the Mentat directory examples/python/tutorial/c08. The
following Python code obtains the nodal scalar values from the post file used in the previous chapter:
1. from py_post import *
2. def main(fname):
3. p = post_open(fname)
4. try:
5. p.moveto(1)
6. except:
7. print ‘Error opening post file: ‘,fname
8. return
9.
10. max_scalars = []
11. max_nodes = []
64 Marc Python Tutorial

12.
13. nns = p.node_scalars()
14. print "Found ", nns, " node scalars "
15. for i in range(0,nns):
16. max_scalars.append(-1.0e20)
17. max_nodes.append(0)
18.
19. # find maximum nodal scalars
20. for j in range(0, nns):
21. k= 0
22. numnodes = p.nodes()
23. while k < numnodes:
24. d = p.node_scalar(k,j)
25. if d < 0.0:
26. d = -d
27. if d > max_scalars[j] :
28. max_scalars[j] = d
29. max_nodes[j] = p.node_id(k)
30. k = k + 1
31.
32. print " Label node scalar"
33. print " ---------------------------------------"
34.
35. for i in range(0,nns):
36. str = " %18s %10i %g" % (p.node_scalar_label(i),
max_nodes[i],max_scalars[i])
37. print str
38. return
39.
40. if __name__ == '__main__':
41. main("../c06/chap5_job1.t16")
CHAPTER 8 65
PyPost: Reading a Post File

Line 3 The post_open routine is called with the post file name chap5_job1.t16. It returns the PyPost
object that is stored in the variable p. All subsequent PyPost methods called will be members of this
PyPost object.
Lines 4-5 The max_scalars and max_nodes variables are declared as Python Lists. The index of the list
will be each of the scalars in the post file. The maximum scalar value will be stored in the
max_scalars list. The node associated with the max_scalar value will be stored in the
max_nodes list.
Line 7 Go to the first increment.
Lines 4-8 We call the moveto method to go to the first increment using the try/except statements to check for
an error. When the post file is opened, it is at increment 0. Increment 0 contains only the model data.
We need to explicitly go to the first increment even though there is only one increment of data in the
post file.
Lines 10-11 The max_scalars and max_nodes variables are declared as Python Lists. The index of the list
will be each of the scalars in the post file.
Line 13 This statement will call the node_scalars method to obtain the total number of nodal scalars
stored in the post file.
Lines 15-17 The lists are initialized.
Line 20 This begins the main loop for the scalars.
Line 22 Obtain the number of nodes. If this post file had multiple increments, we would have to call the nodes
method every increment, since rezoning will change the number of nodes.
Line 23 Loop through all the nodes. Note that we use a while loop for this. We had been using the range
function, however, Python builds a list of all the values in the range for this function. If we had
100,000 nodes, Python would build a list that large.
Line 24 Get the scalar value for this scalar (k) and node (j).
Lines 25-26 Ignore the sign of the values and only work with magnitudes.
Lines 27-29 Check the current value against the current maximum value. Convert the node sequence number to
the node id using the node_id method.
Lines 35-37 Print out the results for each scalar.

Running the Script

This script is intended to be run outside of Mentat. In an X-terminal window or a Microsoft Windows command prompt
window, change your directory to the Mentat directory examples/python/tutorial/c08. Run the Python script chap8.py
as:
python chap8.py
When the script completes, the output is printed as shown in Figure 8-1.
66 Marc Python Tutorial

Found 6
node scalars
Label node scalar
-------------------------------------------
Displacement x 53 0.00128282
Displacement y 49 0.00565143
External Force x 1 0
External Force y 50 187.5
Reaction Force x 82 2866.6
Reaction Force y 81 921.814

Figure 8-1 Resulting Output from chap8.py

In the next chapter, we will begin working with element data.

Chapter 9: PyPost: Obtaining Element Data

9 PyPost: Obtaining Element Data


Chapter Overview 68

Processing Element Data 68
 Running the Script 72
68 Marc Python Tutorial

Chapter Overview
In this chapter, it will be demonstrated how to obtain element data from a post file. This example will use the post file
of that created in Chapter 6: PyMentat: Processing a Post File.
Upon completion of this chapter you should have a clearer understanding of the following areas:
• Obtaining the element data from a post file
• The element extrapolation methods available

Processing Element Data

In the previous chapter, you saw how to use the Pypost module to process nodal data. In this chapter, we will process
element data.
Processing the element data is more complex since elements contain multiple nodes and integration points. The values
obtained at the nodes are obtained by extrapolating the values at the integration points. There are three extrapolation
methods available through the extrapolation method:

linear Extrapolate by averaging the integration points to the centroid of the element and then doing a
linear extrapolation from the centroid through the integration point to the node.
translate Do not extrapolate, but rather copy the data at each integration point to its corresponding node. In
those cases where there are fewer integration points than nodes, some averaging of neighboring
integration points may be done.
average The average of all the integration points is computed and assigned to the nodes. Therefore, all
nodes have an equal value assigned to them.

Consider the quadrilateral element shown Figure 9-1.

CHAPTER 9 69
PyPost: Obtaining Element Data

4 7 3 4 7 3

3 4

8 6 8 6

1 2

1 5 2 1 5 2
Eight node quadrilateral Four Gaussian integration points
Node
Integration pt
Figure 9-1 Element Class 8: Eight Noded Isoparametric Quadrilateral Elements

The quadrilateral element of Figure 9-1 contains eight nodes and four integration points. For this element, the PyPost
method of element_scalar will return a list of eight nodes and eight scalar values. If the extrapolation method is
average, all eight nodes will have the same value. If the extrapolation method is translate, then node 5 would be
calculated by averaging integration points 1 and 2. If the integration method is linear, then all four integration points
are averaged together and computed for the centroid of the element. The values for the nodes are linearly extrapolated
from the centroid to their position on the element.
This example is named chap8.py and can be found in the Mentat directory examples/python/tutorial/c08. The
following is the Python code:
1. from py_post import *
2. def main(fname):
3. p = post_open(fname)
4. try:
5. p.moveto(1)
6. except:
7. print ‘Error opening post file: ‘,fname
8. return
9.
10. max_scalars = []
11. max_nodes = []
12. max_incs = []
13. nns = p.node_scalars()
70 Marc Python Tutorial

14. nes = p.element_scalars()

15.
16. ninc = p.increments()
17. print " Increments = ",ninc,", Nodal scalars = ",nns, ",
Element scalars ",nes
18.
19. for i in range(0,nns+nes):
20. max_scalars.append(-1.0)
21. max_nodes.append(0)
22. max_incs.append(0)
23.
24. for i in range(1, ninc):
25. p.moveto(i)
26. print "scanning increment ",i," post file number ",p.increment
27.
28. # find maximum nodal scalars
29. j = 0
30. while j < nns:
31. k = 0
32. numnodes = p.nodes()
33. while k < numnodes:
34. d = p.node_scalar(k,j)
35. if d < 0.0:
36. d = -d
37. if d > max_scalars[j] :
38. max_scalars[j] = d
39. max_nodes[j] = p.node_id(k)
40. max_incs[j] = p.increment
41. k = k + 1
42. j = j + 1
43.
44. # find maximum element scalars
45. j = 0
46. while j < nes:
CHAPTER 9 71
PyPost: Obtaining Element Data

47. k = 0
48. numelems = p.elements()
49. while k < numelems:
50. sca = p.element_scalar(k,j)
51. l = len(sca)
52. m = 0
53. while m < l :
54. val = sca[m]
55. if val < 0.0:
56. val = -val
57. if val > max_scalars[nns+j] :
58. max_scalars[nns+j] = val
59. max_nodes[nns+j] = nod[m]
60. max_incs[nns+j] = p.increment
61. m = m + 1
62. k = k + 1
63. j = j + 1
64.
65. print " Item Label increment node scalar"
66. print " ------------------------------------------"
67.
68. for i in range(0,nns+nes):
69. if i < nns:
70. s = p.node_scalar_label(i)
71. else:
72. s = p.element_scalar_label(i-nns)
73. str = "%7i %36s %7i %10i %g" % ((i+1),s,max_incs[i],
max_nodes[i],max_scalars[i])
74. print str
75.
76. return
77.
78. if __name__ == '__main__':
79. main("../c06/chap5_job1.t16")
72 Marc Python Tutorial

Line 3 The post_open routine is called with the post file name chap5_job1.t16. It returns the PyPost
object that is stored in the variable p. All subsequent PyPost calls will be members of this PyPost
object.
Lines 4-8 We call the moveto method to go to the first increment using the try/except statements to check for an
error. When the post file is opened, it is at increment 0. Increment 0 contains only the model data. We
need to explicitly go to the first increment even though there is only one increment of data in the post
file.
Lines 10-12 The max_scalars, max_nodes, and max_incs variables are declared as Python Lists. The
index of the list will be each of the scalars in the post file. The maximum scalar value will be stored
in the max_scalars list. The node associated with the max_scalar value will be stored in the
max_nodes list and the associated increment will be stored in the max_incs list.
Lines 13-14 The node_scalars method is called to obtain the total number of nodal scalars and the
element_scalars method is called to obtain the total number of element scales stored in the post
file.
Lines 19-22 The lists are initialized. Note that the lists contain both the nodal and element scalar data.
Line 24 The outer loop is the one for the increments.
Lines 25-26 We call the moveto method with the current index number to step through the increments. Remember
that the index number passed in the moveto method is not the same number as that which appears in
the post file. In line 21, we print out the current index number, and the increment number as it appears
in the post file.
Lines 29-42 This is the nodal scalars section, which is the same as that of the previous chapter.
Lines 45 Begin the loop for the element scalars.
Lines 48-49 Obtain the number of elements in the current increment. Rezoning may cause the number of elements
to change between increments. Loop through all the elements.
Line 50 Obtain the element scalars. The element_scalar method will return a list of PyScalar values. A
PyScalar has two members: an id and a value. The id represents the node ID, and value represents the
scalar value.
Line 53 Loop over every node in the list.
Line 54 The PyScalar list returned is "read-only". This means that the values in the list cannot be changed.
Lines 55-60 Check each value in the PyScalar list and compare them to the maximum values.
Lines 65-74 Print out the results for each scalar.

Running the Script

This script is run similar to that of the previous chapter. In an X-terminal window or Microsoft Windows command
prompt window, change your directory to the Mentat directory examples/python/tutorial/c09. Run the Python script
chap9.py as:
python chap9.py
CHAPTER 9 73
PyPost: Obtaining Element Data

When the script completes, the output will be appear as shown in Figure 9-2.

Increments = 26 , Nodal scalars = 9 , Element scalars 6

Item Label increment node scalar

---------------------------------------------------------------------------
1 Displacement x 240 1 0.829858
2 Displacement y 190 23 0.0844004
3 Displacement z 240 75 1.83052
4 External Force x 240 60 216.668
5 External Force y 240 66 357.812
6 External Force z 0 1 0
7 Reaction Force x 240 18 4017.09
8 Reaction Force y 220 98 111.656
9 Reaction Force z 240 18 1.24391
10 Equivalent Von Mises Stress Layer 1 240 44 106931
11 Equivalent Von Mises Stress Layer 3 240 24 77594.8
12 Equivalent Von Mises Stress Layer 5 240 24 103107
13 Equivalent Plastic Strain Layer 1 240 45 0.181767
14 Equivalent Plastic Strain Layer 3 240 24 0.0871299
15 Equivalent Plastic Strain Layer 5 240 23 0.211298

Figure 9-2 Resulting Output from chap9.py

In the next chapter, we will write a simple script to find the stresses greater than a given value.
Chapter 10: PyPost: Element Tensor Data

10 PyPost: Element Tensor Data


Chapter Overview 75

Processing Element Tensor Data 75
 Running the Script 78
CHAPTER 10 75
PyPost: Element Tensor Data

Chapter Overview
In this chapter, it will be demonstrated how to use the PyPost module to examine the element tensors. This example
will use the post file of that created in Chapter 6: PyMentat: Processing a Post File.
Upon completion of this chapter, you should have a clearer understanding of the following areas:
• Obtaining the element tensors
• Working with elements tensor data in a Python script

Processing Element Tensor Data

In the previous chapter, you saw how to use the PyPost module to process nodal and element scalar data. In this chapter,
we will process the element tensor data and use the PyTensor data type.
This example is named chap10.py and can be found in the Mentat directory examples/python/tutorial/c10. The Python
code is as follows:
1. from py_post import *
2. import sys
3. class TensorData:
4. def __init__(self, v, n, i):
5. self.Value = v
6. self.Node = n
7. self.Inc = i
8.
9. def set_data(self, v,n,i):
10. self.Value = v
11. self.Node = n
12. self.Inc = i
13.
14. def increment(self):
15. return self.Inc
16.
17. def value(self):
18. return self.Value
19.
20. def node(self):
21. return self.Node
76 Marc Python Tutorial

22.
23. def get_tensors(fname):
24. p = post_open(fname)
25. try:
26. p.moveto(1)
27. except:
28. print ‘Error opening post file: ‘,fname
29. return
30.
31. max_values = []
32.
33. net = p.element_tensors()
34. ninc = p.increments()
35. print "Found ", net, " element tensors "
36. print ninc, " increments "
37.
38. if net == 0 :
39. print "Did not find element tensors"
40. return
41.
42. for i in range(0,net):
43. max_values.append(TensorData(0.0, 0, 0))
44.
45. i = 1
46. while i < ninc:
47. print "Scanning increment ",i
48. p.moveto(i)
49.
50. j = 0
51. while j < net:
52. k = 0
53. num = p.elements()
54. while k < num:
55. el = p.element_tensor(k,j)
CHAPTER 10 77
PyPost: Element Tensor Data

56. l = len(el)
57. m = 0
58. while m < l :
59. d = el[m].intensity
60. if d > max_values[j].value() :
61. max_values[j].set_data(d, el[m].id, i)
62. m = m + 1
63. k = k + 1
64. j = j + 1
65.
66. i = i + 1 # next increment
67.
68. print " Item Label increment node tensor"
69. print " ------------------------------------------"
70.
71. for i in range(0,net):
72. j = max_value[i].node()
73. s = p.element_tensor_label(i)
74. str = "%7i %16s %7i %10i %g" %
((i+1),s,max_values[i].increment(),
j,max_values[i].value())
75. print str
76. return 1
77.
78. def main(fname):
79. get_tensors(fname)
80. return
81.
82. if __name__ == '__main__':
83. main(sys.argv[1])

Line 2 The system module sys is imported to provide access to the command line arguments.
Lines 3-21 A Python class is created to hold and retrieve the data.
Line 24 The post_open routine is called with the post file name passed in as the first command line
argument.
78 Marc Python Tutorial

Lines 25-29 We call the moveto method to go to the first increment using the try/except statements to check for an
error. When the post file is opened, it is at increment 0. Increment 0 contains only the model data. We
need to explicitly go to the first increment even though there is only one increment of data in the post
file. This must be performed before we attempt to get any data from the post file, such as the number
of element scalars available.
Lines 33-34 The number of element tensors and the number of increments in the post file are obtained.
Line 46 Begin the increment loop.
Line 53 Obtain the number of elements in this increment. Rezoning may cause the number of elements to
change between increments.
Lines 55-58 Obtain the list of PyTensors, and find the length of the list.
Lines 58-61 For each item in the list, compare it to the maximum value. The set_data method of the
TensorData class is used to set the values.
Lines 71-75 Print the results. In line 69, the node method of the TensorData class is called to obtain the node ID.
Line 83 The filename is specified as the first argument to the script.

Running the Script

This script is run similar to that of the previous chapter. In an X-terminal window or Microsoft Windows command
prompt window, change your directory to the Mentat directory examples/python/tutorial/c10. Run the Python script
chap10.py as:
python chap10.py chap10.t16
When the script completes, the output appears as shown in Figure 10-1.

Found 2 element tensors

12 increments
Scanning increment 1
Scanning increment 2
Scanning increment 3
Scanning increment 4
Scanning increment 5
Scanning increment 6
Scanning increment 7
Scanning increment 8
Scanning increment 9
Scanning increment 10
Scanning increment 11
Item Label increment node tensor
----------------------------------------------------------
1 Stress 4 15 58564.1
2 Plastic Strain 6 9 0.103661
Figure 10-1 Resulting Output from chap10.py
Chapter 11: PyMentat: Using the py_connect Method

PyMentat: Using the py_connect

11 Method

Chapter Overview 80
 Creating a Simple Python Script for Marc Mentat 80

The py_connect Method 80

Handling Socket Errors 81
 Running the Script 82
80 Marc Python Tutorial

Chapter Overview
In this chapter, it will be demonstrated how to use Mentat Parameters in a Python script using the PyMentat module.
It will also be shown how to run a Python script as a separate process. Upon completion of this chapter, you should
have a clearer understanding of the following areas:
• The py_connect method
• Handling socket errors

Creating a Simple Python Script for Marc Mentat

We will use the Python script shown in Chapter 3: PyMentat: Obtaining Data from Mentat which will create a simple
element grid and use Mentat Parameters to control the size of the grid. This example is named chap3.py and can be
found in the Mentat directory examples/python/tutorial/c03. The code is shown completely in Chapter 3: PyMentat:
Obtaining Data from Mentat; however, what we are interested in now is at lines 41-44 as follows:

12. if __name__ == ’__main__’:

13. py_connect("",40007)
14. main()
15. py_disconnect()
If the script is invoked as a separate process, (such as python chap3.py), then the Python interpreter sets the Python
variable __name__ to the string __main__. If this is the case, then the Python script should attempt to make a
socket connection to Mentat. The first argument to py_connect is the hostname, and if it is NULL, it will use the
local host. The second argument is the port number.

The py_connect Method

The py_connect method provides a method in which a Python script performs a BSD socket connection to Mentat
to send commands and obtain parameters. It allows Mentat to be fully interactive while the Python script is executing.
When the Run command in the Python menu is selected, it will bring up the Python browser window. An option in the
Python browser window is Run As Separate Process. If this is enabled, then Mentat will initiate a socket connection
using the command for the Initiate Connection menu item, and then the Python script is run using the python interpreter
(python.exe on Microsoft Windows) program located in Mentat’s bin directory. The Python script will need to complete
the connection using a call to the PyMentat method py_connect, specifying the hostname and the port number to
be used. The port number used in the Python script must be the same as specified in Marc Mentat, and may be changed
by selecting the Port button. The hostname may be blank (an empty string), in which case the connection will be
attempted on the local host.
All output from the Python script will appear in Mentat’s XTerm window on Unix or the Command Prompt window
on Microsoft Windows. When Python scripts ends it should call the py_disconnect method to complete the
termination of the socket connection.
CHAPTER 11 81
PyMentat: Using the py_connect Method

Handling Socket Errors

Sometimes a socket may become unusable and Mentat cannot make a connection to a certain port. A port number may
be described as "in use", even though it appears that no Python script is running. You should check that no "zombie"
Python process is running in the background (using the ’ps’ command on Unix or the Task Manager on Microsoft
Windows). If a Python process is running and it has a connection to the port, it must terminate before another process
can make a connection to that port.
The error "Specified address in use" may occur in the following scenario on a Unix system:
1. Mentat is started and the Initiate Connection button is selected.
2. In a separate window, a Python script makes a successful socket connection to Mentat.
3. Mentat exits before the Python script completes or calls the py_disconnect method.
4. Mentat is started again, and the Initiate Connection button is selected. The error "Specified address in use" may
occur. To resolve the problem, use a different port number or wait for the socket timeout to occur (about 4-5
minutes).
If all else fails, try using a different port number. You may also want to specify the port number as an argument to the
Python script. You may do this as shown in the following code example:
1. import sys
2. if __name__ == ’__main__’:
3. port = 40007
4. if len(sys.argv) > 1:
5. port = sys.argv[1]
6. py_connect("",port)
7. main()
8. py_disconnect()
The sys module is used to obtain the "command line arguments", which contains the Python list attribute named argv.
The first item in the argv list in the name of the script being run, and is therefore sys.argv[0]. If the length of this list
is greater than 1, then extra arguments were passed to the Python script. In this example, you would run the script on
the command line as:
python chap3.py 40008
The script would use the port number of 40008 and attempt to make the socket connection with Mentat. The script
could also be run using the Python browser window, shown in Figure 11-1. In this case, the Run As Separate Process
button would be selected, and you would also specify the port number in the Call Arguments text box.
82 Marc Python Tutorial

Figure 11-1 Python Browser Window

Running the Script

First, start Mentat. Before running this example, some Parameters need to be defined. The values for these parameters
will be obtained by the Python script to control the size and the position of the grid.
Select the following menus:

MAIN
UTILS
PARAMETERS
NEW PARAMETER
x_size
10
y_size
8
x_start
-1.0
y_start
-1.0

Remember to press the carriage <CR> after typing in each of the numbers to create the parameters. The procedure file
chap3.proc may be executed to perform the above commands for you if you wish.
CHAPTER 11 83
PyMentat: Using the py_connect Method

You may also type the *define command in Mentat’s command prompt window to create or edit the parameter. For
example, to create the parameter x_size you would type
*define x_size 10
As in the previous chapter, bring up the Python browser window with the menus:

MAIN
UTILS
PYTHON
RUN

When the script completes, a mesh is created the same as in Chapter 3: PyMentat: Obtaining Data from Mentat.
Chapter 12: PyPost: Plotting

12 PyPost: Plotting

Chapter Overview 85

Charting Script for Mentat 85
 The Gnuplot Module 88

The PyOpenGL Module 92
CHAPTER 12 85
PyPost: Plotting

Chapter Overview
In this chapter, it will be demonstrated how to use third party Python modules in a Python script to plot the results from
a post file. Three examples of plotting will be shown:
• Using the gdchart module to create a GIF plot
• Using the gnuplot module to create charts with Gnuplot.
• Using the OpenGL module to display 3-D models with PyOpenGL.

The examples shown here were developed only for Microsoft Windows. See the readme.txt file in the
examples/python/tutorial/c12 directory for information regarding what needs to be installed to run these
examples.

Charting Script for Mentat

In this first example, we will use a simple charting module that creates a JPEG file. We will use it here to create a plot
of the Y displacements for four nodes. Note that this module is somewhat limited since it does not support annotations
and has no support for legends. However, it can be useful for creating quick and simple plots. We will use a post file
which displays a simple contact example. This example is named chap12a.py and can be found in the Mentat directory
examples/python/tutorial/c12. The output from this example is a JPEG file name chap12a.jpg.
The following is the Python code to use the gdchart module to create a JPEG plot.
1. from py_post import *
2. import gdchart
3. opt = gdchart.option
4.
5. opt(set_color=(0xff8080, 0x8080ff, 0x80ff80))
6. opt(bg_color=0xaaaaaa, plot_color=0x0000cd, line_color=0x000000)
7. size = (450, 450)
8.
9. def do_plot(fname, t, Incs, dta):
10. opt(set_color=(0xff8080, 0x8080ff, 0x80ff80))
11. opt(bg_color=0xaaaaaa, plot_color=0x0000cd,
12. line_color=0x000000,format=gdchart.GDC_JPEG)
13. opt(title=t, xtitle='Increment', ytitle=' Y-Displ',grid=1)
14. f=open(fname,’wb’)
15. gdchart.chart(gdchart.GDC_LINE, size, f,
16. Incs, dta[0], dta[1], dta[2], dta[3])
17. f.close()
86 Marc Python Tutorial

18.
19. def main(fname):
20. p = post_open(fname)
21. p.moveto(1)
22. nns = p.node_scalars()
23. ninc = p.increments()
24. print " Increments = ",ninc
25.
26. # The list of nodes to plot
27. check_nodes = (42, 66, 78, 86)
28.
29. # Create an array for the displacements of
30. # the nodes in the list
31. displacements = [None]*len(check_nodes)
32. for i in range(0,len(check_nodes)):
33. displacements[i] = [0.0] * ninc
34.
35. Incs = [' '] * ninc
36.
37. nlocy = 0
38. for i in range(0,nns):
39. s = p.node_scalar_label(i)
40. if s == "Displacement Y" :
41. nlocy = i
42.
43. for i in range(1, ninc):
44. p.moveto(i)
45. print "scanning post file increment",p.increment
46. Incs[i] = `p.increment`
47.
48. # get the Y displacements for specified nodes
49. for k in range(0,len(check_nodes)):
50. j = p.node_sequence(check_nodes[k])
51. displacements[k][i] = p.node_scalar(j,nlocy)
CHAPTER 12 87
PyPost: Plotting

52.
53. title = "Nodes "
54. for k in range(0,len(check_nodes)-1):
55. title = title + `check_nodes[k]` + ","
56. title = title + `check_nodes[len(check_nodes)-1]`
57.
58. do_plot("chapt12a.gif", title, Incs ,displacements)
59.
60. if __name__ == '__main__':
61. main("../c09/chap9.t16")

Line 2 The chart module gdchart is imported.

Lines 9-17 The do_plot routine is a convenient wrapper function to the plotting routine chart in the gdchart
module. We pass in the filename for the plot, the title, and the X and Y values to plot.
Line 27 Create the list of nodes IDs to plot.
Lines 31-33 Create a two-dimensional array for the displacements. The list is the size [number of nodes to plot] x
[number of increments].
Line 35 Create a string array for the increments.
Line 38-41 Find the index to the displacements for the node scalars.
Line 43 Loop through all the increments.
Lines 49-51 Loop over the list of nodes to plot. Use the node_sequence routine to get the sequence number
for the IDs in the check_nodes list.
Lines 53-56 Create the title for the plot. It will contain the list of the nodes used in the plot.

In this example, you would run the script on the command line as:
python chap12a.py
The output from the script is shown in Figure 12-1.
88 Marc Python Tutorial

Figure 12-1 The Resulting JPEG File from chap12a.py

The Gnuplot Module

The gnuplot module interfaces with the Gnuplot program to create PostScript plots. It does not create plots on its own.
Instead, it communicates with the Gnuplot program in much the same way as the PyMentat module communicates with
Mentat. The gnuplot module sends commands to the Gnuplot program, and plots appear in the Gnuplot window. This
module is more robust than the gdchart module because it supports annotations and provides much more control over
the plot.
1. from py_post import *
2. import os
3.
4. try:
5. # Check if the package has been installed correctly
6. import Gnuplot
CHAPTER 12 89
PyPost: Plotting

7. except:
8. print "Gnuplot has not been installed"
9.
10. def gnu_plot(fname, title, Incs, dta, check_nodes):
11. import time
12. g = Gnuplot.Gnuplot(debug=1)
13.
14. g.title(title)
15. g('set data style linespoints')
16. g('set size .6,.6')
17. d = [None] * len(check_nodes)
18. for i in range(0,len(check_nodes)):
19. d[i] = Gnuplot.Data(Incs, dta[i], title="Node "
+ `check_nodes[i]`, with='lines ' + `i+3`+ ' ' + `i+3`)
20. g.xlabel('Increments')
21. g.ylabel('Y-Displ')
22. g.plot(d[0], d[1], d[2], d[3])
23. if os.name == "nt" :
24. raw_input('Please press return to continue...\n')
25. else :
26. time.sleep(5)
27.
28. g.hardcopy(fname, color=1) # enhanced = 1
29. print '**** Saved plot to postscript file "%s" ****\n' % fname
30. time.sleep(1)
31. return
32.
33. def main(fname):
34. p = post_open(fname)
35.
36. p.moveto(1)
37. nns = p.node_scalars()
38. ninc = p.increments()
39. print " Increments = ",ninc
90 Marc Python Tutorial

40.
41. check_nodes = (42,66,78, 86)
42. displacements = [None]*len(check_nodes)
43. for i in range(0,len(check_nodes)):
44. displacements[i] = [0.0] * ninc
45.
46. Incs = [0] * ninc
47. nlocy = 0
48.
49. # find the index for the displacements
50. for i in range(0,nns):
51. s = p.node_scalar_label(i)
52. if s == "Displacement Y" :
53. nlocy = i
54.
55. for i in range(1, ninc):
56. p.moveto(i)
57. print "scanning post file increment",p.increment
58. Incs[i] = p.increment
59.
60. # find all y displacements for specified nodes
61. for k in range(len(check_nodes)):
62. j = p.node_sequence(check_nodes[k])
63. dy = p.node_scalar(j,nlocy) # k
64. displacements[k][i] = dy
65.
66. gnu_plot("chap12b.ps", "Node Displacements", Incs, displacements,
check_nodes)
67.
68. if __name__ == '__main__':
69. main("chap12.t16")

Lines 4-8 Use the try/except statement to trap an error if the module gnuplot is not available.
Line 10 The gnu_plot routine is a convenient wrapper function to the plotting routine Gnuplot in the
gnuplot module.
CHAPTER 12 91
PyPost: Plotting

Line 12 Create the Gnuplot object.

Lines 14-15 Set the title, the linestyle, and the size of the plot.
Line 16 Create an array to store the Gnuplot Data objects.
Line 18-19 Loop through each node in the ccheck_nodes list and create a title containing the node number
and set the line color to a different color for each line.
Lines 20-21 Set the x and y axis labels.
Line 22 Call the plot routine to generate the plot. When the plot routine is called, the data is sent to the gnuplot
program and the plot is displayed.
Line 23-26 If the platform is Microsoft Windows, pause the display. Otherwise wait for five seconds and then
exit.
Line 28 Create the postscript file.
Line 30 Sleep (or pause) the program. If this is not done, a file is not generated.
Lines 33-66 The main routine is similar to that of the chap12a.py example.

When the script completes, a plot as shown in Figure 12-2 is displayed in the Gnuplot program, and is saved as a
PostScript plot in the file chap12b.ps.

Figure 12-2 Resulting PostScript File from chap12b.py

92 Marc Python Tutorial

The PyOpenGL Module

The OpenGL module is an interface to the PyOpenGL API that can be used by Python scripts to draw 3-D graphics.
It is useful to create 3-D graphs, plots, or to display the model itself which will be shown in this example. The original
model and the final displaced model will be displayed.
The post file model is a 2-D model from the Chapter 9: PyPost: Obtaining Element Data example. It requires the
PyOpenGL module and the Numeric extensions from LLNL.
1. from py_post import *
2. from Numeric import *
3. from OpenGL.GL import *
4. from OpenGL.Tk import *
5. from OpenGL.GLUT import *
6.
7. # list of the nodes to label
8. check_nodes = [1,4,7,45]
9.
10. class Displ:
11. def __init__(self, i, xv, yv, dxv, dyv):
12. self.Id = i
13. self.X = xv
14. self.Y = yv
15. self.dX = dxv
16. self.dY = dyv
17. def x(self):
18. return self.X
19. def y(self):
20. return self.Y
21. def dx(self):
22. return self.dX
23. def dy(self):
24. return self.dY
25. def id(self):
26. return self.Id
27.
CHAPTER 12 93
PyPost: Plotting

28. class Win:

29. def __init__(self, left, right, bottom, top, w, h):
30. self.Left = left
31. self.Right = right
32. self.Bottom = bottom
33. self.Top = top
34. self.Width = w
35. self.Height = h
36. def left(self):
37. return self.Left
38. def right(self):
39. return self.Right
40. def bottom(self):
41. return self.Bottom
42. def top(self):
43. return self.Top
44. def width(self):
45. return self.Width
46. def height(self):
47. return self.Height
48.
49. def width():
50. return 400
51.
52. def height():
53. return 400
54.
55. def mode_3d():
56. global win
57. glMatrixMode(GL_PROJECTION)
58. glLoadIdentity()
59. glOrtho(win.left(), win.right(), win.bottom(),win.top(), -1.0,1.0)
60. glMatrixMode(GL_MODELVIEW)
61.
94 Marc Python Tutorial

62. BMfonts = ( "glut9by15", "glut8by13",

63. "glutTimesRoman10", "glutTimesRoman24",
64. "glutHelvetica10", "glutHelvetica12", "glutHelvetica18" )
65.
66. # draw a symbol for the node
67. def draw_dot(x,y):
68. dot = array([0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,0xFFFFFFFF,
69. 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,0xFFFFFFFF])
70. glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
71.
72. wid = 3
73. hei = 3
74. glRasterPos3f(x,y,0.0)
75. t=dot.tostring()
76. glDrawPixels(wid, hei, GL_RGBA, GL_UNSIGNED_BYTE, t)
77. return
78.
79. def draw_string(str,x,y):
80. glRasterPos3f(x,y,0.0)
81. for i in range(len(str)):
82. glutBitmapCharacter("glut9by15", ord(str[i]));
83. return
84.
85. def draw_element(i):
86. # draw the original shape
87. glColor3f(1,0,0)
88. glBegin(GL_LINE_STRIP)
89. glVertex2f(nodex[i], nodey[i])
90. glVertex2f(nodex[i+1], nodey[i+1])
91. glVertex2f(nodex[i+2], nodey[i+2])
92. glEnd()
93. # draw the deformed shape
94. glColor3f(0,1.0,0.0)
95. glBegin(GL_LINE_STRIP)
CHAPTER 12 95
PyPost: Plotting

96. glVertex2f(nodedx[i], nodedy[i])

97. glVertex2f(nodedx[i+1], nodedy[i+1])
98. glVertex2f(nodedx[i+2], nodedy[i+2])
99. glEnd()
100. return
101.
102. def plot_nodes(lst):
103. global p
104. glColor3f(1,1,1)
105. for i in range(len(lst)):
106. j = p.node_sequence(lst[i])
107. k=lst[i]
108. draw_string(`k`,nod[j].x(), nod[j].y())
109. draw_dot(nod[j].x(), nod[j].y())
110. dx = nod[j].x()+nod[j].dx()
111. dy = nod[j].y()+nod[j].dy()
112. draw_string(`k`,dx, dy)
113. draw_dot(dx,dy)
114. return
115.
116. def draw_legend():
117. global win
118. glColor3f(1,0,0)
119. glBegin(GL_LINE_STRIP)
120. x1 = win.left() + .1
121. x2 = x1 + (win.right()-win.left())/5.0
122. y = win.bottom() +.15
123. glVertex2f(x1, y)
124. glVertex2f(x2, y)
125. glEnd()
126. draw_string("undeformed", x2+.05, y)
127. glColor3f(0,1.0,0.0)
128. glBegin(GL_LINE_STRIP)
129. glVertex2f(x1, y-.1)
96 Marc Python Tutorial

130. glVertex2f(x2, y-.1)

131. glEnd()
132. draw_string("deformed",x2+.05, y-.1)
133. return
134.
135. def redraw(o):
136. glClearColor(0.1, 0.1, 0.1, 0)
137. glColor3f(1,0,0)
138. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
139. mode_3d()
140.
141. glDisable(GL_LIGHTING)
142. for i in range(0,len(nodex),3):
143. draw_element(i)
144. plot_nodes(check_nodes)
145. draw_legend()
146. glEnable(GL_LIGHTING)
147. return
148.
149. def find_node(n,nod):
150. for i in range(0,len(nod)):
151. if nod[i].id() == n:
152. return i
153. return -1
154.
155. def find_maxmin(x, y):
156. global maxx, maxy, minx, miny
157. if maxx < x : maxx = x
158. if maxy < y : maxy = y
159. if minx > x : minx = x
160. if miny > y : miny = y
161.
162. def main(fname):
163. global nodex, nodey, nodedx, nodedy
CHAPTER 12 97
PyPost: Plotting

164. global maxx, maxy, minx, miny

165. global nod # List of Displ objects
166. global win
167. global o, p
168.
169. p = post_open(fname)
170. p.moveto(1)
171. nns = p.node_scalars()
172.
173. ninc = p.increments()
174. print " Increments = ",ninc
175.
176. # find the index ih the scalar label list for the displacements
177. for i in range(0,nns):
178. s = p.node_scalar_label(i)
179. if s == "Displacement X" :
180. nlocx = i
181. if s == "Displacement Y" :
182. nlocy = i
183.
184. # go to the last increment
185. p.moveto(p.increments()-1)
186. k = 0
187.
188. # get nodes
189. nod = [Displ] * p.nodes()
190. while k < n:
191. j = p.node_id(k)
192. i = k
193. np = p.node(k)
194. dx = p.node_scalar(k,nlocx)
195. dy = p.node_scalar(k,nlocy)
196. nod[k] = Displ(j,np.x, np.y,dx,dy)
197. k = k + 1
98 Marc Python Tutorial

198.
199. k = 0
200. n = p.elements()
201.
202. # Create the x and y coordinate arrays for plotting.
203. # We should check the element list to find out how many
204. # nodes are in each element.
205. # We know for this model all elements have 3 nodes.
206. nodex = [0.0]*(n*3)
207. nodey = [0.0]*(n*3)
208. nodedx = [0.0]*(n*3)
209. nodedy = [0.0]*(n*3)
210. maxx = maxy = -10000.0
211. minx = miny = 10000.0
212.
213. cnt=0
214. # build the x and y coordinate arrays
215. while k < p.elements():
216. el = p.element(k)
217. for m in range(0,el.len):
218. id=find_node(el.items[m],nod)
219. if id >=0 :
220. nodex[cnt] = nod[id].x()
221. nodey[cnt] = nod[id].y()
222. nodedx[cnt] = nod[id].x() + nod[id].dx()
223. nodedy[cnt] = nod[id].y() + nod[id].dy()
224. find_maxmin(nodex[cnt], nodey[cnt])
225. find_maxmin(nodedx[cnt], nodedy[cnt])
226. cnt = cnt+1
227. k = k +1
228.
229. # Generate the Win object containing the viewport info
230. minx = minx - .25*(maxx-minx)
231. maxx = maxx + .25*(maxx-minx)
CHAPTER 12 99
PyPost: Plotting

232. miny = miny - .25*(maxy-miny)

233. maxy = maxy + .25*(maxy-miny)
234. win = Win(minx, maxx,miny, maxy, width(), height())
235.
236. f = Frame()
237. f.pack(side='top',expand=1)
238. quit=Button(f,text = 'Quit',command =sys.exit).grid(row = 0,
column = 0, sticky =W)
239.
240. t = "Increments " + `p.increments()`
241. lbl = Label(f, text=" ").grid(row=0, col=2, sticky=W)
242. lbl = Label(f, text=t).grid(row=0, col=3, sticky=W)
243. o = Opengl(width = width(), height = height(), double = 1)
244. o.redraw = redraw
245. o.pack(side = 'top', expand = 1, fill = 'both')
246. o.focus_set()
247. o.mainloop()
248.
249. if __name__ == '__main__':
250. main("../c09/chap9.t16")

Line 2 Import the Numeric (NumPy) extension.

Lines 3-5 Import the OpenGL, OpenGL toolkit (Tkinter), and the OpenGL GLUT modules.
Lines 10-26 Create a class for storing the displacement data.
Lines 28-47 Create a class for storing information about the window.
Lines 49-53 The width and height function to return the desired size. Change the values here to change the size
of the window.
Lines 55-60 The mode_3d routine sets the OpenGL parameters for a 3-D window.
Lines 62-64 The BMfonts list contains the available fonts for displaying in the 3-D window.
Lines 66-77 The drawdot routine draws a 3x3 block of pixels. This is used to identify the nodes we wish to see
labelled.
Lines 79-83 The draw_string routine draws a string of characters at the specified position in the 3-D window
Lines 85-100 The draw_element routine draws both the deformed and the undeformed elements.
Lines 102-114 The plot_nodes routine draws the "dot" to represent the node location and will label the node for
both the deformed and undeformed elements.
100 Marc Python Tutorial

Lines 116-133 The draw_legend routine draws a legend in the lower left corner reflecting the color of the lines
used for the deformed and undeformed shape.
Lines 135-147 The redraw routine is called by the Tkinter toolkit (which is registered at line 247) to redraw the
window. It calls the mode_3d routine to setup the 3-D window, and then draws the elements, plots
the nodes, and draws the legend. If the window is resized or receives an expose event, the toolkit
will call this routine.
Lines 149-153 The find_node routine finds the index of a node id in the nod array.
Lines 155-160 The find_maxmin routine finds the maximum and minimum x and y values in the model. This is
used to determine the values to specify when creating the 3-D window.
Lines 163-167 Declare some global variables.
Lines 176-182 Determine the index of the X and Y displacements in the post file.
Lines 188-197 Create an array of Displ objects to store the displacement data. Loop over all of the nodes and
create an object.
Lines 206-209 Create the arrays to store the actual x and y coordinates to plot.
Line 215 Loop through all the elements.
Lines 217-226 For each node in the element, get the index of the node in the nod array and store the data in the
undeformed x and y arrays (nodex and nodey), and also in the deformed x and y arrays (nodedx
and nodedy). The find_maxmin routine is called to find the maximum and minimum values so that
the window may be scaled appropriately.
Lines 229-234 Find the minimum and maximum values for the data so that the window can be created with the
proper limits.
Lines 236-237 Create the window frame using the Tkinter toolkit.
Lines 238-242 Create a quit button and a label that specifies the number of increments.
Lines 243-247 Create the OpenGL object and specify the width, height and whether double buffering is needed.
Specify the redraw routine (line 244) and get the window focus. Then start the main loop event
processing (line 247).
CHAPTER 12 101
PyPost: Plotting

Figure 12-3 The Resulting Plot from chap12c.py

Chapter 13: PyMentat: Menu System Lookup Functions

PyMentat: Menu System Lookup

13 Functions

Chapter Overview 103
 Menu System Lookup Functions 103

Integer Function 104

Double Function 104
 String Function 104

Boolean Function 105

State Function 106
CHAPTER 13 103
PyMentat: Menu System Lookup Functions

Chapter Overview
In this chapter the basics of obtaining database values using the menu system lookup functions will be demonstrated.
Upon completion of this chapter, you should have a clearer understanding of the following areas:
• The fundamentals of the menu system lookup functions.
• How to use the lookup functions in a Python script to obtain database values.

Menu System Lookup Functions

This chapter describes how to obtain database value by accessing them using the menuing system lookup functions
supported by Mentat. Each function has two arguments: the first argument is the name of the database (menu) item,
the second argument is the index of the item (base 0). The index value is non-zero where lists of items are used, such
as obtaining values of post time on a post file for each increment or a list of contact body names, otherwise the index
will be zero.
The lookup functions supported are:

Integer py_ms_int
Double py_ms_double
String py_ms_string
Boolean py_ms_bool
State py_ms_state

The list of possible database item names are quite long and are not listed here - the name of the item should be obtained
via the menu file. To obtain the name of a database item, run Mentat, and when viewing the required item on a menu
screen, place the cursor over the desired menu item and press the F2 function key to view/edit the menu file. On a Unix
system, the cursor goes directly to the menu item; however, on Microsoft Windows, you need to do a search to get to
the proper location. For example, open a model file or a post file and go to the UTILS->SIZES menu. Place the cursor
over the COUNT item in the ELEMENTS row and press the F2 button. On a Unix system, the cursor is brought to the
proper location which displays an integer database item displaying db_count_elements. For this case, the
function call uses the py_ms_int function to retrieve the value:
nelems = py_ms_int(‘db_count_elements’,0)
For Microsoft Windows users that are using the default editor, you need to do a search of “COUNT” (that is, search
for part of the table’s title) to get to the proper menu text. If you have a ‘vi’ editor for Microsoft Windows, you can use
that instead by modifying the bin\edit_window.bat script.
The names of some items may require spaces to be used in the text; however, this is not allowed in the Python text
strings. Substitute a ‘&’ or a ‘@’ symbol for any embedded spaces.
104 Marc Python Tutorial

Integer Function
The database values for integer items may be obtained using the py_ms_int function. The first argument is the name
of the database item, the second argument is the index of the item. Any item in a menu file that is represented as an
integer may be obtained, such as:
integer {
position +10 =
size 10 4
display ‘db_count_nodes’
}
The Python code for this example would be:
nnodes = py_ms_int(‘db_count_nodes’,0)
The index value is nonzero where lists of items are used, such as the values on a post file for each increment. An
example would be post_size: The following obtains the post file size data for the 6th increment on the post file:
n = py_ms_int(‘post_size’,5)

Double Function
The database values for floating point (float or double) items may be obtained using the py_ms_double function.
The database may store items either as a double or a float; hence, for float items, the value is cast as a double and
returned. The first argument is the name of the database item, the second argument is the index of the item. Any item
in a menu file that is represented as a float may be obtained, for example:
float {
position +26 =
size 12 4
display lcase_time_step
}
The Python code for this example would be:
tstep = py_ms_double(‘lcase_time_step’,0)
An example of a menu item that uses a non-zero index would be post_time: The following obtains the post file time
value for the 6th increment on the post file:
n = py_ms_double(‘post_time’,5)

String Function
The database values for string or text items may be obtained using the py_ms_string function. The first argument
is the name of the database item, the second argument is the index of the item. Any item in a menu file that is
represented as a text item (character string) may be obtained, for example:
text {
position +1 +4
CHAPTER 13 105
PyMentat: Menu System Lookup Functions

size 30 4
display post_file
command ‘*post_open’
}
The Python code for this example would be:
tstep = py_ms_string(‘post_file’,0)
In some cases a text value of an integer or floating point value are displayed. In these cases the string will appear as
display d_gmodel_data_defmag
display i_geomdist_grid_div
The first character denotes the data type, such as i for integer or d for double (float).
The index value is non-zero where lists of items are used, such as the values on a post file for each increment. An
example would be post_time: The following obtains the name of the second contact body in a model file:
str = py_ms_string(‘cbody_list_name’, 1)

Boolean Function
The database values for boolean items may be obtained using the py_ms_bool function. The first argument is the
name of the database item, the second argument is the index of the item. Any item in a menu file that is represented as
a toggle or a oneonly may be obtained, for example:
toggle {
position +15 =
size 8 4
text ‘GRID’
true_command ‘*set_grid on’
false_command ‘*set_grid off’
toggle set_grid
}
oneonly {
position 1 +4
size 10 4
text ‘FOLLOWER FORCE’
commands ‘*job_option follow:on’
oneonly ‘*job_option follow:on’
}
The Python code for the examples shown above would be:
bGrid = py_ms_bool(‘set_grid’,0)
bFollow = py_ms_bool(‘*job_option&follow:on’,0)
The grid example returns 1 if the grid is on; false if it is off. The job_option example returns true if the follower
force option is on; false if not. If an option has multiple states, then the State function is used. The job_option of
follower force actually has four states, so the state function should be used to get the active state.
106 Marc Python Tutorial

State Function
The database values for state items may be obtained using the py_ms_state function. State items are similar to
boolean items, except that in most cases they have multiple conditions, but not in all cases (such as
acis_file_check). The first argument is the name of the database item, the second argument is the index of the
item.
There are much fewer state items than integer, double, string or booleans, and the return values may not be clear, hence
they are listed in the following table. A state item is generally represented in a menu file that is defined as a roller item,
however it may also appear as a oneonly. Note that in some cases the name will include the preceding asterisk, simliar
to that of the actual command. A menu example for a roller button is as follows:
roller {
position 1 1
size 36 4
nvalues 4
texts ‘NO FOLLOWER FORCE’
‘FOLLOWER FORCE’
‘FOLLOWER FORCE/STIFFNESS’
‘FOLLOWER FORCE/(BEGIN INC)’
commands ‘*job_option follow:off’
‘*job_option follow:on’
‘*job_option follow:stiffness’
‘*job_option follow:begin_inc’
roller ‘job_option follow’
}

The Python code for this example would be:

bType = py_ms_state(‘job_option&follow’,0)
The state values will generally (but not always) begin at 0 for the first item listed and increment by one for each item
in the texts list. Note that functions that end with option or param have a space after the name and are followed by
the name of the option. The possible arguments for the option or param types are numerous - when the item you require
is found in a menu file, view the file to obtain the required argument. For an example, consider job_option. The best
way to verify the correct state value is to use py_send to send the command and then obtain the state value:
py_send(‘*job_option style:single’)
bOpt = py_ms_state(‘job_option&style’,0)
print ‘ job style single has state ’, bOpt

Table 13-1 State Functions

Function Description
acis_file_type *set_acis_formatted command state: returns 0 if Acis file type is
formatted, 1 if binary.
acis_file_check *set_acis_entity_check command state: returns 0 if entity check
is off, 1 if on.
adapg_option
CHAPTER 13 107
PyMentat: Menu System Lookup Functions

Table 13-1 State Functions

Function Description
adapg_param
apply_option
bsect_grid_type Returns 0 for rectangular, 1 for cylindrical
bsect_option
carea_option
cavity_option
connect_option
coord_system Coordinate system type: 0 for rectalngular, 1 for cylindrical, 2 for
sphereical.
crdsyst_option
crdsyst_type Coordinate system type: 0 for rectalngular, 1 for cylindrical, 2 for
sphereical.

ctable_bodies_option
ctable_entry
curve_div_applyrest_state *set_curve_div_applyrest_<cvs|lps> command state:
0 = individual cuirves (cvs), 1 = detected loops (lps).
curve_div_tol_state State of *set_curve_div_tol_(rel, abs) commands:
0 = relative, 1 = absolute.
geometry_option
job_option
job_post_eq_layers Post layers: 0 for default, 1 for All, 2 for out&mid, 3 for list.
match_mesh_dir *set_match_mesh_dir state: 0 = from side a to b, 1 = from side b to a.
mesh_parameter_ SuperForm mesh parameter settings.
mesh_split_method_1d Match split method 1D: 0=element base, 1 = plane
mesh_split_method_2d Match split method 2D: 0=element base, 1 = plane, 3 = smooth
mesh_split_method_3d Match split method 3D: 0=element base, 1 = plane
numerics_format Numerics format: 0 for automatic, 1 for exponential, 2 for floating, 3 for
integer
save_file_type Formatted file type returns 0, binary type returns 1
select_filter 0 = none, 1 = outline, 2 = surface, 3 = top, 4 = bottom
select_method 0 = single, 1 = path, 2 = box, 3 = user_box, 4 = plane, 5 = flood,
6 = associate, 7 = point_dist, 8 = curve_dist, 9 =s urface_dist
108 Marc Python Tutorial

Table 13-1 State Functions

Function Description
select_mode 0 = and, 1 = except, 2 = invert, 3 = intersect
servo_match_rtype 0 = side a, 1 = side b, 2 = external, 3 = create new
servo_match_ttype 0 = side a, 1 = side b
set_curve_type Curve type: 0 = line, 1 = circle_cr, 2 = bezier, 3 = nurb, 4 = arc_craa,
5 = polyline, 6 = cubic_spline, 7 = circle_cp, 8 = arc_cpp, 9 = arc_cpa,
10 = arc_ppp, 11 = arc_tra, 12 = composite, 13 = interpolate, 14 = tangent,
15 = fillet, 16 = sampled, 17 = circle_ppp
set_element_class Element class: 0 = line2, 1 = line3, 2 = tria3, 3 = tria6, 4 = quad4, 5 = quad6,
6 = quad8, 7 = quad9, 8 = hex8, 9 = hex12, 10 = hex20, 11 = hex27,
12 = tetra4, 13 = tetra10, 14 = penta6, 15 =p enta16
set_solid_type Solid type: 0 = block, 1 = cylinder, 2 = prism, 3 = sphere, 4 = torus
set_surface_type Surface type: 0 = quad, 1 = sphere, 2 = bezier, 3 = nurb, 4 = ruled,
5 = driven, 6 = cylinder, 7 = swept, 8 = interpolate, 9 = coons, 10 = skin,
11 = sampled
set_insert_embedded_type 0 for elements, 1 for nodes.
set_insert_host_type 0 for elements, 1 for contact bodies‘
set_insert_create Flag for insert generation during rebar remeshing: 0 is off, 1 is on.
set_view_repeat Flag for *set_view_repeat command: 0 is off, 1 is on.
set_xy_draw_type_histplot 0 = curve, 1 = bar, 2 = scatter
set_xy_draw_type_pathplot 0 = curve, 1 = bar, 2 = scatter
set_xy_draw_type_table 0 = curve, 1 = bar, 2 =s catter
set_xy_draw_type_xcurve 0 = curve, 2 = scatter
set_xy_draw_type_xy_plot 0 = curve, 1 = bar, 2 =s catter
set_import_space State of DXF file import for model/paper space: 0 is model, 1 is paper, 2 is
both.
srfprop_option
strline_option
table_indep_vars State of current table’s number of independent variables. Returns : 0 is 1
indep var, 1 is 2 indep var, 2 is3 indep var, 3 is4 indep var,
table_xvar State of current table x axis variables (V1-V4): Returns: 0 is V1, 1 is V2, 2
is V3, 3 is V4.
table_yvar State of current table y axis variables (V1-V4): Returns: 0 is V1, 1 is V2, 2
is V3, 3 is V4.
tform_option
weldpath_option
CHAPTER 13 109
PyMentat: Menu System Lookup Functions

Table 13-1 State Functions

Function Description
xcv_discontinuous State of *xcv_discontinuous command: 0 is off; 1 is on.
xcv_err_abs State of *xcv_err_abs command: 0 is off; 1 is on.
xcv_hyp_tc State of *xcv_hyp_tc command: 0 is tensile; 1 is compressive.
Chapter 14: MentatDCOM: Connecting to Mentat using a .NET Module

MentatDCOM: Connecting to
14 Mentat using a .NET Module

Chapter Overview 111
 MentatDCOM Basics 111

Running the Program 114

MentatDCOM and PyMentat 115
CHAPTER 14 111
MentatDCOM: Connecting to Mentat using a .NET Module

Chapter Overview
In this chapter it will be demonstrated the basics of using the MentatDCOM module to connect to Mentat using
programs created with Microsoft Visual Studio 2005 or later. An example will be shown which uses code similar to
that of the example discussed in Chapter 2.
Upon completion of this chapter, you should have a clearer understanding of the following areas:
• The basics of using MentatDCOM
• How to use MentatDCOM to send data to Mentat

MentatDCOM Basics
In Chapter 2, it was shown how to use PyMentat to connect to Mentat and build a simple model. The MentatDCOM
module is a .NET assembly module built with Microsoft Visual Studio 2005 to provide an API simliar to that of
PyMentat to send and receive data from Mentat. As a .NET assembly module, it allows any .NET module to access the
members functions, using languages such as VB.NET, C#, J#, etc. It connects to Mentat using a DCOM interface which
must be registered in the Microsoft Windows registry before it can be used. This is done by running the *dcom_reg
command in Mentat. This command has to be run only once. The interface remains registered if Mentat is closed.
The DCOM interface is initiated in a Mentat session using the *dcom_init command. The MentatDCOM module
contains a class named MentatData which must be instantiated by the client. This MentatData object contains the
methods that are used to send commands and retrieve various data items. The first method that must be called is used
to start the connection, connect and returns either 0 for a successfull connection or non-zero if there was an error.
Note that the MentatDCOM module (DLL) must be in the same directory as your executable, otherwise it will not be
found.
When using the MentatDCOM module, you will import the module in a similar way as importing the PyMentat
module, using the appropriate language syntax:
C++/CLI
using namespace MentatDCOM;
C#
using MentatDCOM;
VB.Net
Imports MentatDCOM
In the main program, the MentatData object is created which provides acces to the member functions:
C++/CLI
MentatData p = gcnew MentatData();
C#
MentatData p = new MentatData();
112 Marc Python Tutorial

VB.Net
Dim p as New MentatData()
The program example discussed in this chapter will be a C# program performing the same functions as shown in
Chapter 2.
1. using System;
2. using MentatDCOM;
3. namespace MentatTest
4. {
5. class Chap14
6. {
7. static MentatData p;
8. static void make_nodes(int s, int t, double xs, double ys)
9. {
10. int i, j;
11. double x, y, z, delx, dely;
12. y = ys;
13. z = 0.0;
14. delx = 1.0/(double)s;
15. dely = 1.0/(double)t;
16. string str;
17. for(i = 0; i < t; i++)
18. {
19. x = xs;
20. for(j = 0; j < s; j++)
21. {
22. str = "*add_nodes " + x.ToString()
23. + " " + y.ToString() + " " + z.ToString();
24.
25. p.send(str);
26. x = x + delx;
27. }
28. y = y + dely;
29. }
30. return;
CHAPTER 14 113
MentatDCOM: Connecting to Mentat using a .NET Module

31. }
32.
33. static void make_elements(int n, int m)
34. {
35. int i, j, n1, n2, n3, n4;
36. string str;
37. for(i = 1; i < m; i++) // the "y" dir
38. {
39. n1 = (i-1) * (n) + 1;
40. n2 = n1 + 1;
41. n4 = n1 + (n);
42. n3 = n2 + (n);
43. for(j = 1; j < n; j++ ) // the "x" dir
44. {
45. str = "*add_elements "+n1.ToString()+" " +
46. n2.ToString() + " " + n3.ToString() + " " + n4.ToString();
47. p.send(str);
48. n1++;
49. n2++;
50. n3++;
51. n4++;
52. }
53. }
54. return;
55. }
56.
57. static void Main(string[] args)
58. {
59. string host = "local";
60. if (args.Length > 0){
61. host = args[0];
62. }
63. Console.WriteLine("chap14 {0}", host);
64. p = new MentatData();
114 Marc Python Tutorial

65. if (p.connect(host) > 0)

66. {
67. Console.WriteLine("Failed to connect to {0}", host);
68. return;
69. }
70. int n = 6;
71. int m = 8;
72. double xs = -1.0;
73. double ys = -1.0;
74. make_nodes(n, m, xs, ys);
75. make_elements(n, m);
76. p.disconnect();
77. return;
78. } // end Main
79. } // end class
80. }

Lines 1-2 Import the modules to be used. The System module is required for using the WriteLine method, the
MentatDCOM module provides access to the MentatData class.
Lines 7 Declare the MentatData object member.he argument list passed to the main function is checked for
the post file name.
Lines 8-55 This code is similar to the Python code of Chapter 2.
Lines 60-62 The argument list passed to the main function is checked for the host name.
Line 64 The MentatData Object class is initialized. It creates the MentatData object and is stored in the
variable p. All subsequent MentatDCOM methods called will be members of this object.
Lines 65-69 The connect method is called with the hostname of the computer.
Lines 70-75 This code is similar to the Python code of Chapter 2.
Line 76 The disconnect method is called to close the connection.

Running the Program

This script is intended to be run outside of Mentat. In a Microsoft Windows command prompt window, change your
directory to the Mentat directory examples/python/tutorial/c14. Compile and run the C# program chap14.cs as:
csc /r:MentatDCOM.dll chap14.cs /out:chap14_cs.exe
CHAPTER 14 115
MentatDCOM: Connecting to Mentat using a .NET Module

The buildit.bat script will compile the program for you. Start Mentat (from either the shortcut on the desktop or
another command prompt window) and enter the command:
*dcom_init
Run the DCOM program as:
chap14_cs
When the script completes, a mesh will be created as shown in Figure 14-1.

Figure 14-1 Resulting Mentat from chap14.cs

MentatDCOM and PyMentat

The MentatDCOM module methods are very similar to those in PyMentat; howeve,r thre are some minor changes.

connect(String ^host) This method is called py_connect in PyMentat. It initializes the connection to
Mentat. Note that the port number has been removed. It returns zero on success,
non-zero on failure. The host string is currently ignored.
int ret = p.connect(‘localhost’); // C# syntax
int ret = p->connect(‘localhost’); // C++ syntax
ret = p.connect(‘localhost’); ‘ VB syntax
116 Marc Python Tutorial

disconnect() This method is called py_disconnect in PyMentat and closes the DCOM
connection.
p.disconnect();
send() This method is called py_send in PyMentat and sends a command string:
p.send(‘*set_grid on’);
get_string() This method is called py_get_string in PyMentat and returns a string:
String ^nm = p.get_string(‘model_name()’);
Console::WriteLine(‘{0}’, nm);
get_double() This method is called py_get_float in PyMentat. It returns a type of double.
string s = ‘element_mass(-1)’;
double f = p.get_double(s);
Console::WriteLine(‘Mass {0}’, f);
get_int() This method is called py_get_int in PyMentat. It returns a type of integer.
string s = ‘nnodes()’;
int n = p.get_int(s);
Console::WriteLine(‘Node count {0}’, n);
update() This method is called py_update in PyMentat. It forces a graphics update to
allow the image_save routines to function properly.
p.send(‘*image_save_rgb 1 test.rgb yes’);
p.update();
Note that graphics updates will not function properly when running the OpenGL
version of Mentat. The OopenGL graphics engine reports a ‘ERROR_BUSY’
error for the OpenGL calls when a separate process accesses Mentat via DCOM.

Note: The Mentat DCOM module (MentatDCOM.dll) must be in the same directory as your executable,
otherwise it will not be found.
Chapter 15: MarcPost: Reading a Post File using a .NET Module

MarcPost: Reading a Post File

15 using a .NET Module

Chapter Overview 118
 MarcPost Basics 118

Running the Program 121

MarcPost and PyPost 122
118 Marc Python Tutorial

Chapter Overview
In this chapter, it will be demonstrated the basics of using the MarcPost module to read a Marc post file using programs
created with Microsoft Visual Studio 2005 or later. This example will use the post file of the example used in Chapter
6: PyMentat: Processing a Post File.

Upon completion of this chapter, you should have a clearer understanding of the following areas:
• The basics of using MarcPost
• How to use MarcPost to read nodal data

MarcPost Basics
In Chapter 8: PyPost: Reading a Post File, it was shown how to use PyPost to post process a Marc post file. The
MarcPost module is a .NET assembly module built with Microsoft Visual Studio 2005 to provide an API similar to that
of PyPost to obtain the results from a Marc post file. As a .NET assembly module, it allows any .NET module to access
the members functions, using languages such as VB.NET, C#, J#, etc. The MarcPost module contains a method that is
used to open a post file, open (or post_open) and return a PostData object. This PostData object contains the
methods that are used to access various data items in the post file. Note that the MarcPost module (MarcPost.dll)
must be in the same directory as your executable, otherwise it will not be found.
When using the MarcPost module, you will import the module in a similar way as importing the PyPost module, using
the appropriate language syntax:
C++/CLI
using namespace MarcPost;
C#
using MarcPost;
VB.Net
Imports MarcPost
In the main program the PostData object is created which provides acces to the member functions:
C++/CLI
PostData p = gcnew PostData();
C#
PostData p = new PostData();
VB.Net
Dim p as New PostData()
CHAPTER 15 119
MarcPost: Reading a Post File using a .NET Module

The program example discussed in this chapter will be a C# program performing the same functions as shown in
Chapter 8: PyPost: Reading a Post File.

1. using System;
2. using MarcPost;
3. namespace MarcTest
4. {
5. class Chap15
6. {
7. static void Main(string[] args)
8. {
9. if (args.Length < 1){
10. Console.WriteLine("CSPost requires filename");
11. return 1;
12. }
13. Console.WriteLine("CPost {0}", args[0]);
14. PostData p = new PostData();
15. if (p.open(args[0]) > 0)
16. {
17. Console.WriteLine("Failed to open {0}", args[0]);
18. return;
19. }
20. p.moveto(1);
21. int nns = p.node_scalars();
22. Console.WriteLine("Found {0} node scalars", nns);
23. double[] max_scalars = new double[nns];
24. int[] max_nodes = new int[nns];
25. int j, k, numnodes;
26. double d;
27. for(j=0;j<nns;j++) max_scalars[j] = -1.0e20;
28. for(j=0;j<nns;j++)
29. {
30. numnodes = p.nodes();
120 Marc Python Tutorial

31. for(k=0;k<numnodes;k++)
32. {
33. d = p.node_scalar(k,j);
34. if(d < 0.0) d = -d;
35. if(d > max_scalars[j])
36. {
37. max_scalars[j] = d;
38. max_nodes[j] = p.node_id(k);
39. }
40. }
41. }
42. Console.WriteLine(" Label node scalar");
43. Console.WriteLine(" ---------------------------------------------");
44. for(j=0;j<nns;j++)
45. {
46. Console.WriteLine(" {0,20} {1,10:d} {2,-24:g}",
p.node_scalar_label(j),
47. max_nodes[j], max_scalars[j]);
48. }
49. } // end Main
50. } // end class
51. }

Lines 1-2 Import the modules to be used. The System module is required for using the WriteLine method, the
MarcPost module provides access to the PostData class.
Lines 9-12 The argument list passed to the main function is checked for the post file name.
Line 14 The PostData class is initialized. It created the PostData object and is stored in the variable p. All
subsequent MarcPost methods called will be members of this object
Lines 15-19 The open method is called with the post file name chap5_job1.t16.
Line 20 Call the moveto method to go to the first increment. When the post file is opened, it is at increment 0
which contains only the model data. We need to explicitly go to the first increment even though there
is only one increment of data in the post file.
Lines 23-25 The max_scalars and max_nodes variables are declared as arrays. The index of the list will be
each of the scalars in the post file. The maximum scalar value will be stored in the max_scalars
list. The node associated with the max_scalar value will be stored in the max_nodes list.
Line 27 The max_scalars array is initialized.
CHAPTER 15 121
MarcPost: Reading a Post File using a .NET Module

Line 28 This begins the main loop for the scalars.

Line 22 Obtain the number of nodes. If we were processing multiple increments, we would have to call the
nodes method every increment, since rezoning will change the number of nodes.
Line 28 Loop through all the nodes.
Line 33 Get the scalar value for this scalar (k) and node (j).
Lines 25-26 Ignore the sign of the values and only work with magnitudes.
Lines 35-39 Check the current value against the current maximum value. Convert the node sequence number to
the node id using the node_id method.
Lines 44-48 Print out the results for each scalar.

Running the Program

This script is intended to be run outside of Mentat. In a Microsoft Windows command prompt window, change your
directory to the Mentat directory examples/python/tutorial/c15. Compile and run the C# program chap15.cs as:
csc /r:..\..\..\..\shlib\win64\MarcPost.dll chap15.cs \
/out:chap15_cs.exe
on 64-bit Windows.
The buildit.bat script will compile the program for you. Run the program as:
chap15_cs ..\c06\chap5_job1.16
When the program completes, the output will printed as shown in Figure 15-1.

Found 6
node scalars
Label node scalar
-------------------------------------------
Displacement X 53 0.00128282303921878
Displacement Y 49 0.00565143441781402
External Force X 1 0
External Force Y 50 187.5
Reaction Force X 82 2866.59521484375
Reaction Force Y 81 921.813659667969

Figure 15-1 Resulting Output from chap15.cs

122 Marc Python Tutorial

MarcPost and PyPost

The MarcPost module is very similar to the PyPost module, but there are some differences.
The MarcPost object contains the following attributes:

General Description
cutback The total number of cutbacks
cycles The number of recycles for this increment
increment The current increment
separation The total number of separation recycles
split The total number of increment splittings
soltype The dynamic response flag: 0=Normal, 1=Modal, 2=Buckle, 3=Harmonic, 4=Complex.
subinc The current sub-increment. Non-zero for dynamic analysis.
Energy Description (from block 5180n)
creepenergy The total creep strain energy
dampenergy The total damping energy
elasticenergy The total elastic strain energy
energy The total energy
kineticenergy The total kinetic energy
plasticenergy The total plastic strain energy
thermalenergy The total thermal energy
strainenergy The total strain energy
Variables
buckle The buckling factor (for a buckling analysis)
frequency The frequency (for a modal or harmonic analysis). This value is zero for the static increments of the
analysis and non-zero for the dynamic increments
machangle The machine angle (SuperForm only)
pressure The process pressure
time The transient time
mass The total mass
volume The total volume
Work Description (from block 5180n)
appliedwork The total work done by applied force or displacement
contactwork The total work done by contact or external forces
foundwork The total work done by foundations
CHAPTER 15 123
MarcPost: Reading a Post File using a .NET Module

frictionwork The total work due to friction

springwork The total work done by springs
work The total work

The MarcPost module uses the following special types:

Node Nodal Data
id The node ID
x, y, z The x, y, z coordinates of the node
Element Element Data
type The element type
id The element ID
nnode The number of nodes of the element
nodes The list of nodes for the element

The MarcPost module offers the following methods.

int post_open(String ^filename) Opens the specified post file and returns 0 on success and 1 otherwise.
int close() Closes a currently open post file. Returns 0.
String ^title() Returns the title of the post file.
int increments() Returns the number of increments on the post file.
int domains() Returns the number of domains.
void moveto(int i) Moves to the i-th increment on the post file.
position() Returns the current increment on the post file, that is, the increment moved to
by the moveto method. In PyPost, position is an attribute; however, in
MarcPost position is a member function. This change is necessary since it
could be changed by the user; however, the position in the file will not be
updated (use the moveto method instead). Example use:
int pos = p.position();
int nodes() Returns the number of nodes in the model for the current increment. The
number of nodes may change for each increment due to remeshing.
int node_id(int i) Returns the id of the i-th node.
int node_sequence(int id) Returns the index number of a particular node id or -1 if the id does not exist.
Node ^node(int i) Returns the nodal data for the i-th node.
int node_displacements() Returns 1 if displacements are available on the post file and 0 otherwise.
int node_displacement(int i, Returns the x-, y- and z-displacements of the i-th node. The return value if the
double *x, double *y, double* z) method is 0 on success and 1 on failure.
int node_scalars() Returns the number of nodal scalar quantities available.
124 Marc Python Tutorial

double node_scalar(int i, int j) Returns the value of the j-th nodal scalar quantity at the i-th node.
String^ node_scalar_label(int i) Returns the name of the i-th nodal scalar quantity.
int node_vectors() Returns the number of nodal vectors available.
String^ node_vector_label(int i) Returns the name of the i-th nodal vector.
int node_vector(int i, int j, Returns the x-, y-, and z-components of the j-th nodal vector at the i-th node.
double *x, double *y, double *z) The return value of the method is 0.
int elements() Returns the number of elements in the model for the current increment. The
number of elements may change for each increment due to remeshing.
int element_id(int i) Returns the id of the i-th element.
element_sequence(int id) Returns the index number of a particular element id or -1 if the id does not
exist.
Element^ element(int i) Returns the element data for the i-th element.
int element_scalars() Returns the number of element scalars available.
String^ element_scalar_label(int i) Returns the name of the i-th element scalar.
int element_vectors() Returns the number of element vectors available.
String^ elelment_vector_label(int i) Returns the name of the i-th element vector.
int element_tensors() Returns the number of element tensor available.
String^ element_tensor_label(int i) Returns the name of the i-th element vector.
int extrapolation(String^ type) Sets the integration point extrapolation method for element data. The
argument is a string specifying the extrapolation method to use:

• “linear”- Integration point values are interpolated linearly from the

element integration points to the nodes of the element.
• “translate” - Integration point values are copied to the corresponding nodes
of the element.
• “average” - The average of all integration point values are assigned to the
nodes of the element.
Returns 0 on success and 1 otherwise.
int global_values() Returns the number of global quantities available.
String^ global_value_label(int i) Returns the name of the i-th global quantity.
double global_value(int i) Returns the value of the i-th global quantity.
int cbodies() Returns the number of contact bodies.
int cbody_id(int i) Returns the id of the i-th contact body.
String^ cbody_name(int i) Returns the name of the i-th contact body.
double cbody_angle(int i) Returns the angle for the i-th contact body.
double cbody_volume(int i) Returns the volume of the i-th contact body.
CHAPTER 15 125
MarcPost: Reading a Post File using a .NET Module

double cbody_rotation(int i) Returns the rotation for the i-th contact body.
int cbody_displacement(int i, Returns the x-, y-, and z-displacements of the i-th contact body. The return
double* x, double *y, double *z) value of the method is 0 if the body exists and 1 otherwise.
int cbody_force(int i, double* x, Returns the forces in x-, y-, and z-directions for the i-th contact body. The
double *y, double *z) return value of the method is 0 if the body exists and 1 otherwise.
int cbody_moment(int i, Returns the moments about the x-, y-, and z-axes for the i-th contact body. The
double *x, double *y, double *z) return value of the method is 0 if the body exists and 1 otherwise.
int cbody_velocity(int i, Returns the velocities in x-, y-, and z-directions of the i-th contact body. The
double *x, double *y, double *z) return value of the method is 0 if the body exists and 1 otherwise.
int sets() Returns the number of sets on the post file.
String ^version() This method returns the MarcPost module version information:
String ^ver = p.version();
Console::WriteLine(‘{0}’,ver);
Example output Assembly name MarcPost, Version=1.0.0.0,
Culture=neutral, PublicKeyToken=null
Marc Python Reference

Marc Python Reference

Introduction

Introduction

Using the Python Modules 3

Variable Types 3
3 Marc Python Reference

Using the Python Modules

This document describes the routines available to Python scripts that use PyMentat or PyPost interface modules.
PyMentat is the interface module for Python scripts to communicate to Mentat and the PyPost Module is used by a
Python script to read data from a Marc post file.
All Python scripts that need access to the PyMentat module must import the module as:
from py_mentat import *
Similarly, all Python scripts that need access to the PyPost module must import the module as:
from py_post import *
These modules are shared libraries, and hence the exact names of the PyMentat and PyPost modules are platform
dependent. The PyMentat module on most Unix machines is named py_mentat.so, and it is named
py_mentat.pyd on Microsoft Windows, and the PyPost module on most Unix machines is named py_post.so,
and it is named py_post.pyd on Microsoft Windows.
These modules are located in the Marc Mentat bin directory, and the Python interpreter finds these modules via the
environment variable PYTHONPATH. This environment variable is set in the run_python (run_python.bat on
Microsoft Windows) script located in the Marc Mentat bin directory. You should use this script when running a
Python script, however as long as you set PYTHONPATH to the correct location, you may simply run the Python
interpreter (python) directly. It is also located in the Marc Mentat bin directory.
The definition of each routine is listed in alphabetical order.
See the Marc Python Tutorial, Chapter 2: PyMentat: A Simple Example for examples on the use of these modules.

Variable Types
The type definitions for functions and methods used in this manual are as follows:

String A character string. This type is similar to the C type of char, and the FORTRAN type of character*(*)”. A
string may be specified by using either single quotes or double quotes.
Float A floating point value. This is similar to the C type of double and the FORTRAN type of real*8.
Integer An integer (or fixed point) value. This is similar to the C type of long int and the FORTRAN type of
integer*8.
List A Python List object. A Python list is essentially a linked list that can be accessed as an array.
Chapter 1: PyMentat References

1 PyMentat References

PyMentat 5

py_connect 6
 py_disconnect 7

py_echo 8

py_get_data 9
 py_get_float 10

py_get_int 11

py_get_string 12
 py_prompt 13

py_send 14
5 Marc Python Reference

PyMentat
This chapter describes the PyMentat routines.
PyMentat is the interface module for Python scripts to communicate to Mentat. Mentat must be running prior to
invoking any PyMentat routine.
A Python script using PyMentat can be run either in “embedded” mode or as a separate process. If invoked as a separate
process, the py_port/py_connect routines must be the first PyMentat routines called.
All Python scripts that need access to the PyMentat module must import the module as:
from py_mentat import *
CHAPTER 1 6
PyMentat References

py_connect Establishes a socket connection with Mentat

Synopsis
py_connect(String hostname, Integer nPort)

Arguments
hostname Hostname of system to make connection with
nPort Port number

Description
This routine attempts to establish a socket connect with Mentat on the host specified by hostname, using port number
nPort. The hostname can be an IP address or a DNS name. If hostname is an empty string (“”), then the local host is
used.
A Python script executed as a separate process would use this routine to enable it to communicate with Mentat. It must
be the first PyMentat function called. In addition, Mentat should be waiting for a connection (the Mentat command
*py_connect should have been issued).

Example
if __name__ == ”__main__”:
py_connect(”127.0.0.1”, 40007)
main()
7 Marc Python Reference

py_disconnect Terminates a socket connection with Mentat

Synopsis
py_disconnect()

Arguments
None

Description
This routine terminates a socket connect with Mentat after a successful connection with the py_connect routine.

Example
if __name__ == ”__main__”:
py_connect(”127.0.0.1”, 40007)
...
py_disconnect()
main()
CHAPTER 1 8
PyMentat References

py_echo Enables/disables commands to be printed in Mentat’s dialogue area using py_send

Synopsis
py_echo(int flag)

Arguments
flag An integer used to enable/disable echo.

Description
This routine affects command echoing in Mentat’s dialogue area. If flag is set to true (a nonzero value), then the
commands are echoed. If flag is set to false (zero), then commands sent to Mentat are not echoed. This routine is most
helpful in debugging Python scripts. The default setting is on. Note that enabling echo slightly affects performance.
Mentat command echoing for Python scripts may also be enabled in Mentat using the button:
UTILS->PYTHON->SCRIPT ECHO

Example
py_echo(0)# disables echo
py_echo(1) # enables echo
9 Marc Python Reference

py_get_data Returns a floating point value from the database from the current data class

Synopsis
Float py_get_data(String name)

Arguments
name A string representing the database value to be returned.

Description
This routine parses the string specified in name and returns a floating point result. It has the form:
Dataclass:param_name
where Dataclass is one of:
adapg, adaptg, apply, contact_body, contact_table, geometry, icond, job,
loadcase, material
The Dataclass used is the currently selected item. The naming convention for param_name is consistent with that used
in the menu files for displaying floating point values.

Examples
a = py_get_data(‘material:isotropic:young_modulue’)
b = py_get_data(‘job:singularity_thresh’)
c = py_get_data(‘geometry:cont_radius’)
d = py_get_data(‘icond:base_vec1_x’)
e = py_get_data(‘apply:apply_dof_value_x’)
f = py_get_data(‘contact_body:friction’)
f = py_get_data(‘contact_table:ctable1:ctable2:friction’)
CHAPTER 1 10
PyMentat References

py_get_float Evaluates an expression and returns a floating point value

Synopsis
Float py_get_float(String name)

Arguments
name A string representing the expression to be evaluated.

Description
This routine evaluates the expression specified in name and returns a floating point result. Any Arithmetic or Database
function combination may be used in the expression.

Note: The variables created and used in the Python script are not stored by Mentat and are not available to be
used directly in the expression. Mentat parameters may be defined and used for this purpose.

Example
s = py_get_float(‘point_u1(npoints())’)
str = ‘curve_length(0)/curve_ndiv(0)’
d = py_get_float(str)
f = py_get_float(‘node_x(0)*d’) # is invalid
str = ‘node_x(0)*%g’ % d
f = py_get_float(str) # is correct
11 Marc Python Reference

py_get_int Evaluates an expression and returns an integer value

Synopsis
Integer py_get_int(String name)

Arguments
name A string representing the expression to be evaluated.

Description
This routine evaluates the expression specified in name and returns an integer result. Only Database functions may be
used in the expression since the Arithmetic functions are floating point routines.

Note: The variables created and used in the Python script are not stored by Mentat and are not available to be
used directly in the expression. Mentat parameters may be defined and used for this purpose.

Example
str = ‘npoints()’
i = py_get_int(‘npoints()’)
j = py_get_int(‘node_id(i)’) # is invalid
str = ‘node_id(%d)’” % i
j = py_get_int(str) # is correct
CHAPTER 1 12
PyMentat References

py_get_string Evaluates a function or parameter and returns a string

Synopsis
String py_get_string(String name)

Arguments
name A string representing the function or parameter to be returned.

Description
This routine evaluates the function or parameter specified in name and returns a string result. Any database function
that returns a string may be used in the expression, such as set_name() or job_title(). If name is a string that
begins with ‘$’, then it is interpreted as being the name of a PARAMETER that is currently defined and its expression
is returned.

Note: The variables created and used in the Python script are not stored by Mentat and are not available to be
used directly in the name argument. Mentat PARAMETERS may be defined and used for this purpose.

Example
id = py_get_int(‘set_id(1)‘)
nam = py_get_string(‘set_name(%d)’ % id)
typ = py_get_string(‘set_type(%d)’ % id)
print ‘Set ‘,nam, ‘ is type ‘,typ
py_send(‘*define filename myfile.mfd’)
s = py_get_string(‘$filename’)
print ‘Filename: ‘,s
13 Marc Python Reference

py_prompt Prints a string in the Mentat dialogue area

Synopsis
py_prompt(String name)

Arguments
name The string to print in the dialogue area.

Description
This routine prints the string name in the Mentat dialogue area.

Example
py_prompt(”Evaluating Mesh”)
CHAPTER 1 14
PyMentat References

py_send Sends commands to Mentat for execution

Synopsis
py_send(String command)

Arguments
command A string that contains the Mentat command(s) to be executed.

Description
This routine sends the string command to Mentat for execution. The string may contain multiple Mentat commands
(which must be separated by blanks) and can be constructed using standard Python string operations. The command(s)
will be executed just as if they were typed in the Mentat dialog area.
Graphics windows will not be updated automatically after the string has been executed. They will be updated only after
the Python script has finished executing. The special command *py_update can be sent to Mentat to force a refresh
of the graphics windows during execution of the Python script. This command must be used if one wants to create a
snapshot of the graphics window from the Python script. For example, the following two Python commands save a
snapshot of the current graphics window into the file image.png:
py_send(“*py_update”)
py_send(“*image_save_current image.png yes”)

Example
py_send(“*add_nodes %f %f %f” % (x, y, z)) # creates a node at
# position (x,y,z)
Chapter 2: PyPost References

2 PyPost References

PyPost 21

close 25
 cbody 26

cbody_angle 28

cbody_displacement 29
 cbody_force 30

cbody_moment 31

cbody_name 32
 cbody_rotation 33

cbody_transform 34
 cbody_velocity 35
 cbody_volume 36
 cbodies 37

domain 38
 element 39
 elements 40

element_id 41
 element_scalar 42

element_scalars 43

element_scalar_label 44
 element_sequence 45
CHAPTER 2 20
PyPost References


element_tensor 46

element_tensors 47

element_tensor_label 48

element_vector 49

element_vectors 50

element_vector_label 51
 extrapolation 52

global_value 53

global_values 54
 global_value_label 55

increments 56

moveto 57
 node 58

nodes 59

node_displacement 60
 node_displacements 61

node_id 62
 node_scalar 63
 node_scalars 64
 node_scalar_label 65

node_sequence 66
 node_vector 67
 node_vectors 68

node_vector_label 69
 post_open 70

set 71

sets 72
 title 73
 version 74
21 Marc Python Reference

PyPost
This chapter describes the PyPost routines and methods.
The PyPost module is used by a Python script to read data from a Marc post file.
All Python scripts that need access to the PyPost module must import the module as:
from py_post import *
The PyPost object contains attributes that are accessible after opening a post file. For example:
from py_post import *
p = post_open(‘chap19.t16’)
p.moveto(11)
print ‘increment number ‘,p.increment
The PyPost object contains the following attributes:

General Description
cutback The total number of cutbacks
cycles The number of recycles for this increment
extrapolate The current extrapolation method
filename The postfile name associated with this object
increment The current increment
position The current position (as supplied to moveto())
revision The post file revision
separation The total number of separation recycles
split The total number of increment splittings
soltype The dynamic response flag: 0=Normal, 1=Modal, 2=Buckle, 3=Harmonic, 4=Complex.
subinc The current sub-increment. Non-zero for dynamic analysis.
Energy Description (from block 5180n)
creepenergy The total creep strain energy
dampenergy The total damping energy
elasticenergy The total elastic strain energy
energy The total energy
kineticenergy The total kinetic energy
plasticenergy The total plastic strain energy
thermalenergy The total thermal energy
strainenergy The total strain energy
CHAPTER 2 22
PyPost References

Variables
buckle The buckling factor (for a buckling analysis)
frequency The frequency (for a modal or harmonic analysis). This value is zero for the static increments of the
analysis and non-zero for the dynamic increments. The following code segment will search all
increments to find the first dynamic increment.
firstdyn = 0
for i in range(1,ninc):
p.moveto(i)
if p.frequency != 0:
firstdyn = i
Note that soltype can also be check for being non-zero.
machangle The machine angle (SuperForm only)
pressure The process pressure
time The transient time
mass The total mass
volume The total volume
Work Description (from block 5180n)
appliedwork The total work done by applied force or displacement
contactwork The total work done by contact or external forces
foundwork The total work done by foundations
frictionwork The total work due to friction
springwork The total work done by springs
work The total work

The PyPost module uses the following special types:

PyNode Nodal Data

id The node ID
x, y, z The x, y, z coordinates of the node
PyElement Element Data
type The element type
len The number of nodes in the element
items The list of node IDs for the element
PySet Set Data
name The string representing the set name
type The set type, either “node” or “element”
len The number of items in the ‘items’ list
items The list of nodes or elements
23 Marc Python Reference

PyTensor Tensor Data

id The node ID of the tensor, if applicable
t11, t12, t13 First row of tensor matrix. These values in matrix notation would be t(1,1), t(1,2), and t(1,3),
respectively.
t22, t23 Second row of tensor matrix. Since the tensor matrix is symmetric, only the “top right” values
of the matrix are returned. These values in matrix notation would be t(2,2) and t(2,3),
respectively.
t33 Third row of tensor matrix. This value in matrix notation would be t(3,3).
intensity The tensor intensity
PyVector Vector Data
id The node id of the vector, if applicable
x,y,z The x, y, z vector values
PyCurve Curve Data
npoints Number of points
norder Order of curve
points List of points that describe the curve (PyNode)
knots Knot vector. The number of items is npoints+norder.
w Weight values. The number of items is npoints.
PySurface Surface Data
npoints_u Number of points in “u” direction.
npoints_v Number of points in “v” direction.
norder_u Order of surface in “u” direction.
norder_v Order of surface in “v” direction.
points List of points that describe the surface (PyNode). There are npoints_u*npoints_v
number of points. They are arranged in “v” major order, such that:
for i in range(0,npoints_v):
for j in range(0,npoints_u):
print ‘point[%i][%j].x=%12g‘ %
(point[i*npoints_u+j].x)
w List of weight values (floats). They are arranged in “v” major order similar to the points array.
knots_u List of knot values (floats) in “u” direction. There are npoints_u+order_u items.
knots_v List of knot values (floats) in “v” direction. There are npoints_v+order_v items.
ntrim Number of trimming curves
trim List of trimming curves (PyCurve).
PyContactBody Contact Body Data
id The ID of the contact body
name The name of the contact body
CHAPTER 2 24
PyPost References

type The type of the contact body:

0 - deformable
1 - 2-D line elements (type 9)
2 - 3-D patch elements (type 18)
3 - 2-D curves
4 - 3-D surfaces
bodytype The physical type of the contact body:
1 - rigid
2 - deformable structural
3 - symmetry
4 - deformable heat-rigid
5 - workpiece (AutoForge)
6 - deformable acoustic
center_x The center of the contact body
center_y
center_z
axis_x The axis of the contact body
axis_y
axis_z
npoints The number of points in the point array that describe the contact body. This value is nonzero if
the contact body type is 1 or 2.
points Array of PyNode’s that describe the contact body
nelements Number of items in the elements array. This is set if the contact body type is 0. This value may
also be obtained by using len(cb.elements) where cb is the PyContactBody object.
elements List of element IDs that describe the contact body.
npatches Number of items in the patches array. This is set if the contact body type is 2. This value may
also be obtained by using len(cb.patches) where cb is the PyContactBody object.
patches List of PyPatch’s that describe the contact body.
ncurves The number of curves that describe the contact body. This is nonzero if the contact body is type
3. This value may also be obtained by using len(cb.curves) where cb is the
PyContactBody object.
curves List of PyCurve’s that describe the contact body.
nsurfaces The number of surfaces that describe the contact body. This is nonzero if the contact body is
type 4. This value may also be obtained by using len(cb.surfaces) where cb is the
PyContactBody object.
surfaces List of PySurface’s that describe the contact body.
25 Marc Python Reference

close Closes a currently open post file and frees any allocated memory

Synopsis
close( )

Arguments
None

Description
This method closes the post file associated with the PyPost object.

Example
p = post_open(‘c08_job1.t19’)
p.close( )
CHAPTER 2 26
PyPost References

cbody Returns a PyContactBody object for a particular contact body

Synopsis
PyContactBody cbody(Integer index)

Arguments
index Contact body index number

Description
Return a PyContactBody object for contact body index. The cbodies method should be called prior to calling the
cbody method to obtain the total number of contact bodies that are available. The PyContactBody object contains the
geometry for the contact body if the revision of the post file is 8 or higher (member revision of the PyPost object).
This method returns a PyContactBody object.
• PyContactBody Members

id - contact body ID
name - name of the contact body (string)
type - contact body type
0 - deformable
1 - 2-D line elements (line type 9)
2 - 3-D patch elements (elem type 18)
3 - 2-D curves
4 - 3-D surfaces
bodytype - physical type of contact body
1 - rigid
2 - deformable structure
3 - symmetry
4 - deformable heat-rigid
5 - workpiece (SuperForm only)
6 - deformable acoustic

If the contact body type is 0 the following are set:

nelements - number of element items

elements - array of element IDs that comprise the contact body.
27 Marc Python Reference

If the contact body type is 1 the following are set:

nlines - number of lines that comprise the contact body

lines - array of lines (PyPatch’s) that comprise the contact body. The point1 and point2 members of
PyPatch are indices into the points array.

If the contact body type is 2 the following are set:

npatches - number of patches that comprise the contact body

patches - array of patches (PyPatch’s) that comprise the contact body. The point1, point2, point3 and
point4 members of PyPatch are indices into the points array.

If the contact body type is 1 or 2 the following are set:

npoints - number of point items

points - array of points (PyNode’s) that comprise the contact body.

If the contact body type is 3 the following are set:

ncurves - number of curve items

curves - array of curves (PyCurve’s) that comprise the contact body.

If the contact body type is 4 the following are set:

nsurfaces - number of surface items

surfaces - array of surfaces (PySurface’s) that comprise the contact body.

Prior to post revision 8, only rigid contact bodies have the following set:

center_x, center_y, center_z - center of the contact body

axis_x, axis_y, axis_z - axis of the contact body

Also See
cbodies, cbody_name

Example
p = post_open(‘ch03_job1.t16’)
p.moveto(0)
n = p.cbodies()
for i in range(0,n):
d = p.cbody(i)
print ‘contact body id ‘,d.id,’ name ‘,d.name,’
Type ‘,d.type
print ‘Physical type ‘,d.bodytype
CHAPTER 2 28
PyPost References

cbody_angle Returns the angle for a particular contact body

Synopsis
Float cbody_angle(Integer index)

Arguments
index cbody index number

Description
Return the value of the contact body angle at contact body index if available. The cbodies method should be called
prior to calling the cbody_angle method to obtain the total number of cbodies that are available.
This method returns a float.

Also See
cbodies, cbody_name

Example
p = post_open(‘ch03_job1.t16’)
p.moveto(0)
n = p.cbodies()
for i in range(0,p.increments())
p.moveto(i)
for j in range(0,n):
a = p.cbody_angle(i)
29 Marc Python Reference

cbody_displacement Returns the displacement for a particular contact body

Synopsis
Float, Float, Float cbody_displacement(Integer index)

Arguments
index Contact body index number

Description
Return the values of the contact body displacement at contact body index. The cbodies method should be called prior
to calling the cbody_displacement method to obtain the total number of contact bodies that are available.
This method returns three floats.

Also See
cbodies, cbody_name

Example
p = post_open(‘ch03_job1.t16’)
p.moveto(0)
n = p.cbodies()
for i in range(0,p.increments())
p.moveto(i)
for j in range(0,n):
x,y,z = p.cbody_displacement(i)
CHAPTER 2 30
PyPost References

cbody_force Returns the x, y, and z force for a particular contact body

Synopsis
Float, Float, Float cbody_force(Integer index)

Arguments
index Contact body index number

Description
Return the values of the contact body force at contact body index. The cbodies method should be called prior to
calling the cbody_force method to obtain the total number of contact bodies that are available.
This method returns three floats.

Also See
cbodies, cbody_name

Example
p = post_open(‘ch03_job1.t16’)
p.moveto(0)
n=p.cbodies()
n = p.cbodies()
for i in range(0,p.increments())
p.moveto(i)
for j in range(0,n):
x,y,z = p.cbody_force(i)
31 Marc Python Reference

cbody_moment Returns the moment for a particular contact body

Synopsis
Float, Float, Float cbody_moment(Integer index)

Arguments
index Contact body index number

Description
Return the values of the moment for contact body index. The cbodies method should be called prior to calling the
cbody_moment method to obtain the total number of contact bodies that are available.
This method returns three floats.

Also See
cbodies, cbody_name

Example
p = post_open(‘ch03_job1.t16’)
p.moveto(0)
n = p.cbodies()
for i in range(0,p.increments())
p.moveto(i)
for j in range(0,n):
x,y,z = p.cbody_moment(i)
CHAPTER 2 32
PyPost References

cbody_name Returns the name of a particular contact body

Synopsis
String cbody_name(Integer index)

Arguments
index Contact body index number

Description
Return the name contact body index. The cbodies method should be called prior to calling the cbody_name
method to obtain the total number of contact bodies that are available.
This method returns a string.

Also See
cbodies

Example
p = post_open(‘ch03_job1.t16’)
p.moveto(0)
n = p.cbodies()
for i in range(0,n):
print ‘ contact body ‘,p.cbody_id(), ‘ is named ‘,
p.cbody_name(i)
33 Marc Python Reference

cbody_rotation Returns the rotation for a particular contact body

Synopsis
Float cbody_rotation(Integer index)

Arguments
index Contact body index number

Description
Return the value of the contact body rotation for contact body index. The cbodies method should be called prior to
calling the cbody_rotation method to obtain the total number of contact bodies that are available.
This method returns a float.

Also See
cbodies, cbody_name

Example
p = post_open(‘ch03_job1.t16’)
p.moveto(1)
n = p.cbodies()
for i in range(0,p.increments())
p.moveto(i)
for j in range(0,n):
r = p.cbody_rotation(i)
CHAPTER 2 34
PyPost References

cbody_transform Returns the transform for a particular contact body

Synopsis
List Float cbody_transform(Integer index)

Arguments
index Contact body index number

Description
Return the values of the transform for contact body index. The cbodies method should be called prior to calling the
cbody_transform method to obtain the total number of contact bodies that are available.
A transform is actually a 4x4 array of floats, however this method returns an array of 16 floats. They are arranged as
follows:

t0 t1 t2 t3

T = t4 t5 t6 t7
t8 t9 t  10  t  11 
t  12  t  13  t  14  t  15 

Also See
cbodies, cbody_name

Example
p = post_open(‘ch03_job1.t16’)
p.moveto(1)
print cbody_transform(p.cbodies()-1)
35 Marc Python Reference

cbody_velocity Returns the velocity of a particular contact body

Synopsis
Float cbody_velocity(Integer index)

Arguments
index Contact body index number

Description
Return the value for the velocity of the contact body index. The cbodies method should be called prior to calling the
cbody_velocity method to obtain the total number of contact bodies that are available.
This method returns a float.

Also See
cbodies, cbody_name

Example
p = post_open(‘ch03_job1.t16’)
p.moveto(0)
n = p.cbodies()
for i in range(0,p.increments())
p.moveto(i)
for j in range(0,n):
v = p.cbody_velocity(i)
CHAPTER 2 36
PyPost References

cbody_volume Returns the volume of a particular contact body

Synopsis
Float cbody_volume(Integer index)

Arguments
index Contact body index number

Description
Return the value for the volume of the contact body index. The cbodies method should be called prior to calling the
cbody_displacement method to obtain the total number of cbodies that are available.
This method returns a float.

Also See
cbodies, cbody_name

Example
p = post_open(‘ch03_job1.t16’)
p.moveto(0)
n = p.cbodies()
for i in range(0,p.increments())
p.moveto(i)
for j in range(0,n):
v = p.cbody_volume(i)
37 Marc Python Reference

cbodies Returns the number of contact bodies

Synopsis
Integer cbodies()

Arguments
None

Description
Returns the number of contact bodies.

Example
p = post_open(‘c07_job1.t19’)
p.moveto(0)
n = p.cbodies()
CHAPTER 2 38
PyPost References

domain Returns the number of domains in the post file

Synopsis
Integer domains()

Arguments
None

Description
Returns the number of domains in the post file.

Example
p = post_open(‘c07_job1.t19’)
n = p.domains()
39 Marc Python Reference

element Returns the element data for a particular element

Synopsis
PyElement element(int nelem)

Arguments
nelem The element index number

Description
Returns a PyElement object containing the element data for element nelem in the current increment. This data may
change for each increment due to rezoning.

PyElement Members
type - element type
len - number of nodes in the element
items - list of node IDs that comprise the element

Example
p = post_open(‘c08_job1.t19’)
p.moveto(0)
n = p.elements()
for i in range(0,n):
el = p.element(i)
print el
CHAPTER 2 40
PyPost References

elements Returns the number of elements in the current increment

Synopsis
Integer elements()

Arguments
None

Description
Returns the number of elements in the current increment. This may change for each increment due to rezoning.

Example
p = post_open(‘c08_job1.t19’)
p.moveto(0)
n = p.elements()
41 Marc Python Reference

element_id Returns ID of a particular element

Synopsis
Integer element_id(Integer nelem)

Arguments
nelem The element index number

Description
Returns ID of element at index number nelem.

Example
p = post_open(‘c08_job1.t19’)
# print the id’s of each element
p.moveto(0)
n = p.elements()
for i in range(0,n):
print ‘Element ‘,i,’ has id ‘, p.element_id(i)
CHAPTER 2 42
PyPost References

element_scalar Get a list of a particular element scalar for a particular element

Synopsis
List PyScalar element_scalar(Integer nelem, Integer ns)

Arguments
nelem Element index number
ns Scalar index number

Description
Returns a PyScalar list for element scalar nscalar for element at index nelem. A scala is returned for each node in the
element.
This PyScalar list contains the node id and the scalar value. The list returned is read-only, meaning that the values in
the list cannot be changed.

Example
P = post_open(‘c08_job1.t19’)
p.moveto(1)
ne = p.element_scalars()
n = p.elements()
for i in range(0,ne):
for j in range(0,n):
slist = p.element_scalar(j,i)
print ‘Element ‘,j
for k in range(0,len(slist)):
print ‘ Node ‘,slist[k].id, ‘Scalar ‘,
,slist[k].value
slist[k].value = -slist[k].value # Causes Error
43 Marc Python Reference

element_scalars Returns the number of element scalars available

Synopsis
Integer element_scalars()

Arguments
None

Description
Returns the number of element scalars available. This method returns an integer.

Example
P = post_open(‘c08_job1.t19’)
# print the element scalar labels
p.moveto(1)
n = p.element_scalars()
for i in range(0,n):
print p.element_scalar_label(i)
CHAPTER 2 44
PyPost References

element_scalar_label Returns the name of a particular element scalar

Synopsis
String element_scalar_label(Integer nscalar)

Arguments
nscalar Scalar index number

Description
Return the name of element scalar nscalar.
This method returns a string.

Example
p = post_open(‘c08_job1.t19’)
# print the element scalar labels
p.moveto(1)
n = p.element_scalars()
for i in range(0,n):
print p.element_scalar_label(i)
45 Marc Python Reference

element_sequence Returns the index number of a particular element ID

Synopsis
Integer element_sequence(Integer nelem)

Arguments
nelem The element ID

Description
Returns the index number of element with ID nelem. This is the inverse of the element_id method.

Example
p = post_open(‘c08_job1.t19’)
# print the id’s of each element
p.moveto(0)
n = p.elements()
for i in range(0,n):
print ‘Element Id ‘,i,’ index ‘,p.element_sequence(i)
CHAPTER 2 46
PyPost References

element_tensor Get a list of a particular element tensors for a particular element

Synopsis
List PyTensor element_tensor(Integer nelem, Integer ntens)

Arguments
nelem Element index number
ntens Tensor index number

Description
Returns a list of nodes and nodal tensor values for element tensor ntens for element an index nelem. A scalar is returned
for each node in the element.
This PyTensor list contains the node ID and the tensor values. The list returned is read-only, meaning that the values
in the list cannot be changed. This method returns a Python list of PyTensor values.

Example
P = post_open(‘c08_job1.t19’)
p.moveto(1)
ne = p.element_tensors()
n = p.elements()
for i in range(0,ne):
for j in range(0,n):
tlist = p.element_tensor(j,i)
print ‘Element ‘,j
for k in range(0,len(tlist)):
print ‘ Tensor ‘,tlist[k]
47 Marc Python Reference

element_tensors Returns the number of element tensors available

Synopsis
Integer element_tensors()

Arguments
None

Description
Returns the number of element tensors available. This method returns an integer.

Example
P = post_open(‘c08_job1.t19’)
# print the element tensor labels
p.moveto(1)
n = p.element_tensors()
for i in range(0,n):
print p.element_tensor_label(i)
CHAPTER 2 48
PyPost References

element_tensor_label Returns the name of a particular element tensor

Synopsis
String element_tensor_label(Integer ntens)

Arguments
ntens Tensor index number

Description
Return the name of element tensor ntens.
This method returns a string.

Example
p = post_open(‘c08_job1.t19’)
# print the element tensor labels
p.moveto(1)
n = p.element_tensors()
for i in range(0,n):
print p.element_tensor_label(i)
49 Marc Python Reference

element_vector Get a list of a particular element vector for a particular element

Synopsis
List PyVector element_vector(Integer nelem, Integer nv)

Arguments
nelem Element index number
nv Vector index number

Description
Returns a list of nodes and values for element vector nv for element at index nelem. A scalar is returned for each node
in the element.
This PyVector list contains the node id and the vector values. The list returned is read-only, meaning that the values in
the list cannot be changed.
This method returns a Python list of PyVector values.

Example
P = post_open(‘c08_job1.t19’)
p.moveto(1)
ne = p.element_vectors()
n = p.elements()
for i in range(0,ne):
for j in range(0,n):
vlist = p.element_vector(j,i)
print ‘Element ‘,j
for k in range(0,len(vlist)):
print ‘ Vector ‘,vlist[k]
CHAPTER 2 50
PyPost References

element_vectors Returns the number of element vectors available

Synopsis
Integer element_vectors()

Arguments
None

Description
Returns the number of element vectors available. This method returns an integer.

Example
P = post_open(‘c08_job1.t19’)
# print the element vector labels
p.moveto(1)
n = p.element_vectors()
for i in range(0,n):
print p.element_vector_label(i)
51 Marc Python Reference

element_vector_label Returns the name of a particular element vector

Synopsis
String element_vector_label(Integer nscalar)

Arguments
nvec Vector index number

Description
Return the name of element vector nvec. This method returns a string.

Example
p = post_open(‘c08_job1.t19’)
# print the element vector labels
p.moveto(1)
n = p.element_vectors()
for i in range(0,n):
print p.element_vector_label(i)
CHAPTER 2 52
PyPost References

extrapolation Sets the integration point extrapolation method

Synopsis
extrapolation(String type)

Arguments
type A string representing the integration method to use

Description
This method controls the manner in which element integration point data is extrapolated to the nodes of an element. In
addition, they control the inter-element averaging of the nodal data after it has been extrapolated. The available
methods are:

linear Extrapolate by averaging the integration points to the centroid of the element and then doing a
linear extrapolation from the centroid through the integration point to the node.
translate Do not extrapolate, but rather copy the data at each integration point to its corresponding node. In
those cases where there are fewer integration points than nodes, some averaging of neighboring
integration points may be done.
average The average of all the integration points is computed and assigned to the nodes. Therefore, all
nodes have an equal value assigned to them.

Example
P = post_open(‘c08_job1.t19’)
p.extrapolation(‘linear’)
print ‘Extrapolation method is ‘, p.extrapolate
53 Marc Python Reference

global_value Returns the value of a particular global value

Synopsis
Float global_value(Integer index)

Arguments
index Global value index number

Description
Return the value of a particular global value index.
This method returns a float.

Example
# Post file from Userguide Example 3.5
p = post_open(‘airspring_axito3d_wcav_job1.t16’)
ninc = p.increments()
p.moveto(ninc-1)
n = p.global_values()
for i in range(0,n):
print p.global_value_label(i), ‘: ‘, p.global_value(i)

Resulting Output:
Volume Cavity 1 : 0.00172809232026
Pressure Cavity 1 : 1904785.625
Mass Cavity 1 : 0.0363396443427
Temperature Cavity 1 : 300.0
Loadcase Percentage Completion : 0.0
CHAPTER 2 54
PyPost References

global_values Returns the number of global values available

Synopsis
Integer global_values()

Arguments
None

Description
Returns the number of global values available. This method returns an integer.

Example
P = post_open(‘airspring_axito3d_wcav_job1.t16’)
# print the global value labels
n = p.global_values()
for i in range(0,n):
print p.global_value_label(i)
55 Marc Python Reference

global_value_label Returns the name of a particular global value

Synopsis
String global_value_label(Integer index)

Arguments
index Global value index number

Description
Return the name of global value index.
This method returns a string.

Example
p = post_open(‘airspring_axito3d_wcav_job1.t16’)
# print the global value labels
n = p.global_values()
for i in range(0,n):
print p.global_value_label(i)
CHAPTER 2 56
PyPost References

increments Returns the number of increments plus one

Synopsis
Integer increments()

Arguments
None

Description
The number of increments on the post file plus one is returned. Note that a post file starts with a header, which contains
the model data, but no results. This header is included in the increments method. So if a post file only contains
increment 0, the increments method returns two. If a post file contains increment 0 and sub-increments 0:1 and 0:2,
then the increments method returns four. The increments method is often combined with the moveto method
(see moveto) to skip to a particular increment.

Example
p = post_open(‘c08_job1.t19’)
n = p.increments()
57 Marc Python Reference

moveto Moves to the specified increment in the post file

Synopsis
moveto(Integer i)

Arguments
i increment number

Description
Moves to the specified increment in the post file. Increment number 0 only contains the model itself. There is no scalar
data for increment 0. The first increment with data is increment 1.
When the moveto method is called, the following members of the PyPost object are available:

increment increment number

time time of this increment
frequency frequency value of this increment

Example
p = post_open(‘c07_job1.t19’)
p.moveto(4)
print ‘increment ‘,p.increment,’ Time ‘,p.time
print ‘Frequency ‘,p.frequency
CHAPTER 2 58
PyPost References

node Returns the nodal data for a particular node

Synopsis
PyNode node(int nnode)

Arguments
nnode The node index number

Description
Returns a PyNode object containing the nodal data for node at index nnode in the current increment. This data may
change for each increment due to rezoning.

PyNode Members
id - node ID
x - x coordinate
y - y coordinate
z - z coordinate

Example
p = post_open(‘c08_job1.t19’)
p.moveto(0)
n = p.nodes()
for i in range(0,n):
nod = p.node(i)
print "Node index number ",i, " Id ",nod.id
print " x = ",nod.x, " y = ",nod.y," z = ",p.z
59 Marc Python Reference

nodes Returns the number of nodes in the current increment

Synopsis
Integer nodes()

Arguments
None

Description
Returns the number of nodes in the current increment. This may change for each increment due to rezoning.

Example
p = post_open(‘c07_job1.t19’)
p.moveto(0)
n = p.nodes()
CHAPTER 2 60
PyPost References

node_displacement Returns the nodal displacement values at a particular node

Synopsis
Float, Float, Float node_displacement(Integer index)

Arguments
index Node index number

Description
Return the values of the nodal displacement at node index if available. The node_displacements method should
be called prior to calling the node_displacement method to make sure that nodal displacements are available.
This method returns three floats.

Also See
node_displacements

Example
p = post_open(‘c07_job1.t19’)
p.moveto(1)
n = p.nodes()
have_disp = p.node_displacements()
if have_disp:
for i in range(0,n):
x,y,z = p.node_displacement(i)
61 Marc Python Reference

node_displacements Returns a 1 if nodal displacements available; 0 otherwise

Synopsis
Integer node_displacements()

Arguments
None

Description
This method should be used prior to calling the node_displacement method to determine if nodal displacements
are available. Returns 1 if nodal displacements are available; 0 otherwise.

Example
# print the name of each scalar label
p = post_open(’c07_job1.t19’)
p.moveto(1)
if p.node_displacements() :
print "Nodal displacements available"
CHAPTER 2 62
PyPost References

node_id Returns the ID of a particular node

Synopsis
Integer node_id(Integer node)

Arguments
node The node index number

Description
Returns ID of node at index node.

Example
p = post_open(‘c08_job1.t19’)
# print the id’s of each node
p.moveto(0)
n = p.nodes()
for i in range(0,n):
print ‘Node ‘,i,’ has id ‘, p.node_id(i)
63 Marc Python Reference

node_scalar Returns the value of a particular node scalar at a particular node

Synopsis
Float node_scalar(Integer index, Integer scalar)

Arguments
index Node index number
scalar Scalar index number

Description
Return the value of a particular node scalar scalar at a particular node index.
This method returns a float.

Example
# get each scalar for node at index 4
f = [ ]
p = post_open(‘c07_job1.t19’)
p.moveto(1)
n = p.node_scalars()
id = node_id(4)
print ‘node scalars for node id ‘,id
for i in range(0,n):
f.append(p.node_scalar(4, i))
print ‘scalar ‘,f[i]
CHAPTER 2 64
PyPost References

node_scalars Returns the number of node scalars available

Synopsis
Integer node_scalars()

Arguments
None

Description
Returns the number of node scalars available.

Example
# print the name of each scalar label
p = post_open(‘c07_job1.t19’)
p.moveto(1)
n = p.node_scalars()
for i in range(0, n):
print p.node_scalar_label(i)
65 Marc Python Reference

node_scalar_label Returns the name of a particular scalar

Synopsis
String node_scalar_label(Integer index)

Arguments
index Scalar index number

Description
Return the name of node scalar index.
This method returns a string.

Example
# print the name of each scalar label
p = post_open(‘c07_job1.t19’)
p.moveto(1)
n = p.node_scalars()
for i in range(0, n):
print p.node_scalar_label(i)
CHAPTER 2 66
PyPost References

node_sequence Returns the index number of a particular node ID

Synopsis
Integer node_sequence(Integer node)

Arguments
node The node ID

Description
Returns the index number of node with ID node. This is the inverse of the node_id method.

Example
p = post_open(‘c08_job1.t19’)
p.moveto(0)
# print the index of each node
n = p.nodes()
for i in range(0,n):
print ‘Node Id ‘,i,’ has index ‘, p.node_sequence(i)
67 Marc Python Reference

node_vector Returns the value of a particular node vector at a particular node

Synopsis
PyVector node_vector(Integer index, Integer nv)

Arguments
index Node index number
nv Vector index number

Description
Return the vector of a particular node vector nv at a particular node index.
This method returns a PyVector.

Example
# get each vector for node 4
p = post_open(‘c07_job1.t19’)
p.moveto(1)
n = p.node_vectors()
for i in range(0,n):
v = p.node_vector(4, i)
print ‘Vector ‘,i,’ is ‘, v.x, v.y, v.z
CHAPTER 2 68
PyPost References

node_vectors Returns the number of node vectors available

Synopsis
Integer node_vectors()

Arguments
None

Description
Returns the number of node vectors available.

Example
# print the name of each vector label
p = post_open(‘c07_job1.t19’)
p.moveto(1)
n = p.node_vectors()
for i in range(0, n):
print p.node_vector_label(i)
69 Marc Python Reference

node_vector_label Returns the name of a particular node vector

Synopsis
String node_vector_label(Integer index)

Arguments
index Vector index number

Description
Return the name of node vector index.
This method returns a string.

Example
# print the name of each vector label
p = post_open(‘c07_job1.t19’)
p.moveto(1)
n = p.node_vectors()
for i in range(0, n):
print p.node_vector_label(i)
CHAPTER 2 70
PyPost References

post_open Open a post file and return the PyPost object

Synopsis
PyPost post_open(String filename)

Arguments
filename Post file name.

Description
This method opens the specified post file and returns a PyPost object. This is the first PyPost routine that a Python
script should call. A call to moveto( ) should follow to force a reading of the increment data at the first increment
on the post file.

Members
position - current increment position
filename - the post file name
revision - the revision of the post file

The following members are updated when the moveto method is called:

increment - the increment number of post file

time - the time for the current increment
frequency - the frequency of this increment

Example
p1 = post_open(‘e7x14_solver0.t19’)
p1.moveto(0)
p2 = post_open(‘e7x14_solver1.t19’)
p2.moveto(0)
print ‘Comparing ‘,p1.filename, ‘ to ‘,p2.filename
71 Marc Python Reference

set Returns the data for a particular set

Synopsis
PyPostSet set(int nset)

Arguments
nset The set index number

Description
Returns a PyPostSet object containing the set data for set nset in the models.

Members
name - set name
type - set type
len - number of items in the set
items - list of data that comprise the set

Example
p = post_open(‘c08_job1.t19’)
p.moveto(0)
n = p.sets()
for i in range(0,n):
s = p.set(i)
print ‘Name:’,s.name, ‘Type: ‘,s.type
for j in range(0,s.len):
print ‘Item:’,j, ‘Value: ‘,s.items[j]
CHAPTER 2 72
PyPost References

sets Returns the number of sets in the post file

Synopsis
Integer sets()

Arguments
None

Description
Returns the number of sets in the post file.

Example
p = post_open(‘c07_job1.t19’)
p.moveto(0)
n = p.sets()
73 Marc Python Reference

title Returns the title of the post file

Synopsis
String title( )

Arguments
None

Description
Returns the title of the model stored in the post file.
This method returns a string.

Example
# print the title
p = post_open(‘c08_job1.t19’)
print ‘Title: ‘,p.title()
CHAPTER 2 74
PyPost References

version Returns the version of the PyPost module

Synopsis
String version( )

Arguments
None

Description
Return the version string of the PyPost module.
This method returns a string.

Example
print ‘PyPost version is ‘,version()
p = post_open(‘c08_job1.t19’)
Appendix A

Arithmetic and Database

A Functions

Introduction 80
 Arithmetic Functions 80

Database Functions 81

Utility Functions 101
 Post File Database Functions 102

Set Functions 104
CHAPTER A 80
Arithmetic and Database Functions

Introduction
This chapter describes the Arithmetic and Database function supported by Mentat. If the argument to any function is
shown in capital letters (such as ARGn), then the argument is an index and may be negative; in which case, the entities
are counted in reverse order (i.e., ARGn = -1 would refer to the last item). A good example of the usage of these
functions can be found in the Marc User’s Guide, Chapter 31 procedure file. If the argument to a database function is
in lower case (such as argn), then the value is an ID, such as a node ID or an element ID unless otherwise described.

Arithmetic Functions
The following are the Marc Mentat Arithmetic Functions which can be used in the py_get_float or py_get_int
functions or in a formula.

Table A-1 Arithmetic Functions

Function Description
cos(arg1) Cosine of arg1 radians
sin(arg1) Sine of arg1 radians
tan(arg1) Tangent of arg1 radians
dcos(arg1) Cosine of arg1 degrees
dsin(arg1) Sine of arg1 degrees
dtan(arg1) Tangent of arg1 degrees
acos(arg1) Arccosine of arg1 radians
asin(arg1) Arcsine of arg1 radians
atan(arg1) Arctangent of arg1 radians
atan2(arg1,arg2) Arctangent of (arg1/arg2) radians
dacos(arg1) Arccosine of arg1 degrees
dasin(arg1) Arcsine of arg1 degrees
datan(arg1) Arctangent of arg1 degrees
datan2(arg1,arg2) Arctangent of (arg1/arg2) degrees
log(arg1) Base-10 logarithm of arg1
ln(arg1) Natural logarithm of arg1
exp(arg1) E to the power arg1
cosh(arg1) Hyperbolic cosine of arg1
sinh(arg1) Hyperbolic sine of arg1
tanh(arg1) Hyperbolic tangent of arg1
acosh(arg1) Inverse hyperbolic cosine of arg1
asinh(arg1) Inverse hyperbolic sin of arg1
81 Marc Python Reference

Table A-1 Arithmetic Functions (continued)

Function Description
atanh(arg1) Inverse hyperbolic tangent of arg1
sqrt(arg1) Square root of arg1
rad(arg1) Angle in radians of arg1 degrees
deg(arg1) Angle in degrees of arg1 radians
abs(arg1) Absolute value of arg1
int(arg1) Largest integral value not greater than arg1
frac(arg1) Fractional part of arg1
max(arg1,arg2) Maximum of arg1 and arg2
min(arg1,arg2) Minimum of arg1 and arg2
dist2d(arg1,arg2,arg3,arg4) Distance in 2-D space between a point with coordinates (arg1,arg2) and a
point with coordinates (arg3,arg4)
dist3d(arg1,arg2,arg3,arg4,arg5,arg6) Distance in 3-D space between a point with coordinates (arg1,arg2,arg3) and
a point with coordinates (arg4,arg5,arg6)

Database Functions
The following are the Mentat Database Functions which can be used in the py_get_float, py_get_int, or
py_get_string functions.
Note that the database functions may also be used as the argument to many commands. For example:
*remove_elements element_id(-1)
would remove the last element of the model. To use numeric values in a string based command (such as
*job_title), a PARAMETER needs to be created from the database function and then used in the string command.
For example:
*eval_define num nnodes()
*job_title Model with $num nodes
will create an evaluated parameter named num using the nnodes( ) database function, and then use that in the
*job_title command (note the use of the $ to signify it is the name of a parameter). The job title for the CONTACT
demo would appear as:
Model with 72 nodes

Table A-2 Database Functions

Function Description
filename( ) Returns the name of the model file without the path.
getcwd( ) Returns the current directory.
CHAPTER A 82
Arithmetic and Database Functions

Table A-2 Database Functions (continued)

Function Description
model_name( ) Returns the current model name.
revision Returns the string for the base version (such as 2011).
version Returns the string for the version (same as for *version command).
npoints( ) Number of points in database
point_id(arg1) ID of arg1-th point in database
max_point_id( ) Largest point ID in database
point_surface_id(arg1) ID of surface trimmed by point arg1
point_x(arg1) Global X-coordinate of point arg1
point_y(arg1) Global Y-coordinate of point arg1
point_z(arg1) Global Z-coordinate of point arg1
point_u1(arg1) First user coordinate of point arg1
point_u2(arg1) Second user coordinate of point arg1
point_u3(arg1) Third user coordinate of pointarg1
point_s1(arg1) First surface parametric coordinate of point arg1
point_s2(arg1) Second surface parametric coordinate of point arg1
ncurves( ) Number of curves in database
curve_id(arg1) ID of arg1-th curve in database
max_curve_id( ) Largest curve ID in database
ncurve_points(arg1) Number of points of curve arg1
curve_point_id(arg1,arg2) ID of arg2 -th point of curve arg1
curve_surface_id(arg1) ID of surface trimmed by curve arg1
curve_length(arg1) Length of curve arg1
curve_ndiv(arg1) Number of divisions of curve arg1
ncurve_seedpoints(arg1) Number of seed points of a curve. It is identical to
curve_ndiv(arg1)+1.
curve_seedpoint(arg1,arg2) Returns the curve coordinate (between 0 and 1) of the arg2-th seedpoint.
If arg2 is negative, seed points are counted in reverse order (arg2 = -1
would return the last seed point).
nsurfaces( ) Number of surfaces in database
surface_id(arg1) ID of arg1-th surface in database
max_surface_id( ) Largest surface ID in database
nsurface_curves(arg1) Number of trimming curves of surface arg1
surface_curve_id(arg1,arg2) ID of arg2-th curve in database that trims surface arg1
83 Marc Python Reference

Table A-2 Database Functions (continued)

Function Description
nsurface_points_x(arg1) Number of defining points in first parametric direction of surface arg1
nsurface_points_y(arg1) Number of defining points in second parametric direction of surface
arg1
surface_point_id(arg1,arg2,arg3) ID of (arg2, arg3) -the defining point of surface arg1
nsolids( ) Number of solids in database
solid_id(arg1) ID of arg1-th solid in database
nsolid_lumps(arg1) Number of lumps of solid arg1
nsolid_faces(arg1) Number of faces of solid arg1
nsolid_edges(arg1) Number of edges of solid arg1
nsolid_vertices(arg1) Number of vertices of solidarg1
solid_area(arg1) Surface area of solid arg1
solid_volume(arg1) Volume of solid arg1
solid_element_type(arg1,arg2) Element type associated with solid arg1 for elements of class arg2. The
element class argument must be one of the following strings:
line2
line3
tria3
tria6
quad4
quad6
quad8
quad9
tetra4
tetra10
solid_cbody(arg1) Name of the contact body associated with solid arg1
solid_geom(arg1) Name of the geometric property associated with solid arg1
solid_mater(arg1) Name of the material associated with solid arg1
solid_orient(arg1) Name of the material orientation associated with solid arg1
solid_vertex_tform(arg1,arg2) Name of the transformation associated with vertex arg2 of solid arg1
CHAPTER A 84
Arithmetic and Database Functions

Table A-2 Database Functions (continued)

Function Description
solid_vertex_final_tform(arg1,arg2) Name of the effective transformation of vertex arg2 of solid arg1. If the
vertex has a transformation, then the name of this transformation is
returned. If the vertex does not have a transformation itself, then it
inherits the transformation from one of the edges of the solid which
share the vertex, or (if the edges do not have a transformation either)
from one of the faces of the solid which share the vertex, or (if neither
the edges nor the faces have a transformation) from the solid. In that
case, the name of the inherited transformation is returned.
solid_edge_tform(arg1,arg2) Name of the transformation of edge arg2 of solid arg1
solid_edge_final_tform(arg1,arg2) Name of the effective transformation of edge arg2 of solid arg1. If the
edge has a transformation, then the name of this transformation is
returned. If the edge does not have a transformation itself, then it
inherits the transformation from one of the faces of the solid which
share the edge, or (if the faces do not have a transformation either) from
the solid. In that case, the name of the inherited transformation is
returned.
solid_face_tform(arg1,arg2) Name of the transformation of face arg2 of solid arg1
solid_face_final_tform(arg1,arg2) Name of the effective transformation of face arg2 of solid arg1. If the
face has a transformation, then the name of this transformation is
returned. If the face does not have a transformation itself, then it inherits
the transformation from the solid. In that case, the name of the inherited
transformation is returned.
solid_tform(arg1) Name of the transformation of solid arg1
nnodes( ) Number of nodes in database
node_id(arg1) ID of arg1-th node in database
max_node_id( ) Largest node ID in database
node_x(arg1) Global X-coordinate of node arg1
node_y(arg1) Global Y-coordinate of node arg1
node_z(arg1) Global Z-coordinate of node arg1
node_u1(arg1) First user coordinate of node arg1
node_u2(arg1) Second user coordinate of node arg1
node_u3(arg1) Third user coordinate of node arg1
node_tform(arg1) Transform name of node arg1.
85 Marc Python Reference

Table A-2 Database Functions (continued)

Function Description
node_final_tform(arg1) Name of the effective transformation of node arg1; i.e. the
transformation that the node will have in the Marc analysis. This is the
same as node_tform(arg1), unless the node is associated with a solid
vertex, a solid edge, a solid face or a solid and the latter has an
(effective) transformation. In that case, the node inherits the
transformation from the solid entity.
nelements( ) Number of elements in database
element_id(arg1) ID of arg1-th element in database
max_element_id( ) Largest element id in database
element_node_id(arg1,arg2) ID of arg2-th node of element arg1
job_name( ) Name of the job
job_title( ) Title of the job
element_class(arg1) Class of element arg1. Returns an integer:
line2 = 0
line3 = 1
tria3 = 2
tria6 = 3
quad4 = 4
quad6 = 5
quad8 = 6
quad9 = 7
hex8 = 8
hex12 = 9
hex20 = 10
hex27 = 11
tetra4 = 12
tetra10 = 13
penta6 = 14
penta15 = 15
element_class_name(arg1) Similar to element_class(arg1), but returns the name of the element
class of element arg1 as a string, i.e. returns one of:
line2
line3
CHAPTER A 86
Arithmetic and Database Functions

Table A-2 Database Functions (continued)

Function Description
tria3
tria6
quad4
quad6
quad8
quad9
hex8
hex12
hex20
hex27
tetra4
tetra10
penta6
penta15
element_dimension(arg1) Dimension of element arg1 (returns either 2 or 3)
element_family(arg1) Family of element arg1. Returns an integer:
line = 1
tria = 2
quad = 3
hex = 4
tetra = 5
penta = 6
element_edges(arg1) Number of edges for element arg1
element_edge_area(arg1,arg2) Edge area of the arg2-th face of element arg1. If the edge ID arg2 is -1,
then it returns the total edge area of the element.
If the element number arg1 is -1, then it returns the total edge area of all
elements. If the element number arg1 is zero, then it returns the total
edge area of the selected elements.
element_edge_length(arg1,arg2) Edge length of the arg2-th face of element arg1. If the edge ID arg2 is -
1, then it returns the total edge length of the element.
If the element number arg1 is -1, then it returns the total edge length of
all elements. If the element number arg1 is zero, then it returns the total
edge length of the selected elements.
87 Marc Python Reference

Table A-2 Database Functions (continued)

Function Description
element_faces(arg1) Number of faces for element arg1
element_face_area(arg1,arg2) Face area of the arg2-th face of element arg1. If the face ID arg2 is -1,
then it returns the total face area of the element
If the element number arg1 is -1, then it returns the total face area of all
elements. If the element number arg1 is zero, then it returns the total
face area of the selected elements.
element_face_volume(arg1,arg2) Face volume of the arg2-th face of element arg1. If the face ID arg2 is
-1, then it returns the total face volume of the element.
If the element number arg1 is -1, then it returns the total face volume of
all elements. If the element number arg1 is zero, then it returns the total
face volume of the selected elements.
element_mass(arg1) Mass of element arg1. If the element number arg1 is -1, then it returns
the total mass of all elements. If the element number arg1 is zero, then
it returns the total mass of the selected elements.
element_nodes(arg1) Number of nodes for element arg1
element_volume(arg1) Volume of element arg1. If the element number arg1 is -1, then it returns
the total volume of all elements. If the element number arg1 is zero, then
it returns the total volume of the selected elements.
element_type(arg1) Element type associated with element ID arg1.
For example, obtain type of last element:
element_type(element_id(-1))
element_final_type(arg1) The effective element type of element ID arg1; i.e., the element type that
the element will have in the Marc analysis. This is the same as
element_type(arg1), unless the element is associated with a solid and an
element type has been associated with the solid for the element class of
this element. In that case, the element inherits the element type from the
solid.
element_cbody(arg1) Contact body name associated with element ID arg1
element_final_cbody(arg1) Name of the effective contact body associated with element ID arg1;
i.e., the contact body with which the element will be associated in the
Marc analysis. This is the same as element_cbody(arg1), unless the
element is associated with a solid and the solid is associated with a
contact body. In that case, the element inherits the contact body from the
solid.
element_geom(arg1) Geometric property name associated with element ID arg1
CHAPTER A 88
Arithmetic and Database Functions

Table A-2 Database Functions (continued)

Function Description
element_final_geom(arg1) Name of the effective geometric property associated with element ID
arg1; i.e., the geometric property that the element will have in the Marc
analysis. This is the same as element_geom(arg1), unless:
1. The element is associated with a solid and the solid has a geometric
property (in which case, the element inherits the geometry property
from the solid); or
2. The element is a line element and does not have a geometric
property itself, but its edge is attached to a curve with a geometric
property (in which case, the element inherits the geometric property
from the curve); or
3. The element is a triangular or quadrilateral element and does not
have a geometric property itself, but its face is attached to a surface
with a geometric property (in which case, the element inherits the
geometric property from the surface).
element_mater(arg1) Material name associated with element ID arg1
element_final_mater(arg1) Name of the effective material associated with element ID arg1; i.e., the
material that the element will have in the Marc analysis. This is the same
as element_mater(arg1), unless the element is associated with a solid
and the solid has a material. In that case, the element inherits the
material from the solid.
element_orient(arg1) Orientation property name associated with element ID arg1
element_final_orient(arg1) Name of the effective orientation property associated with element ID
arg1; i.e., orientation property that the element will have in the Marc
analysis. This is the same as element_orient(arg1), unless the element is
associated with a solid and the solid has an orientation property. In that
case, the element inherits the property from the solid.
nadapgs( ) Number of global remeshing criterion in the database
adapg_par(arg1,arg2) Parameter value named arg2 for the global remeshing criteria named
arg1. If arg1 is empty, then it uses the current global remeshing criteria.
Example:
adapg_par(adapg1,nelems)
adapg_name_index(ARG1) Global remeshing criterion name of ARG1-th global remeshing
criterion in database.
89 Marc Python Reference

Table A-2 Database Functions (continued)

Function Description
adapg_opt(arg1,arg2) Option string for option arg2 for the current global remeshing criterion
named arg1. If arg1 is empty, then it uses the current global remeshing
criterion.
Example:
adapg_opt(adapg1,immediate_crit)
adapg_type(arg1) Global remeshing criterion type for global remeshing criterion arg1. If
arg1 is empty, then it uses the current global remeshing criterion.
napplys( ) Number of boundary conditions in the database
apply_name_index(arg1) Boundary condition name of arg1-th boundary condition criterion in
database.
apply_opt(arg1,arg2) Option string for option named arg2 for the apply named arg1. If arg1 is
empty, then it uses the current apply. Option strings use same syntax as
in the *apply_option command.
Example:
apply_opt(apply1,ref_position)
apply_par_table(apply1,x) Parameter table name parameter named arg2 for the apply named arg1.
If arg1 is empty, then it uses the current apply. Parameter values use
same syntax as in the *apply_dof_table command
Example:
apply_par_table(apply1,x)
apply_type(arg1) Boundary condition type for boundary condition named arg1. If arg1 is
empty, then it uses the current boundary condition.
apply_par(arg1,arg2) Parameter value named arg2 for the apply (boundary condition) named
arg1. If arg1 is empty, then it uses the current boundary condition.
Example:
apply_par(apply1,temp_inf)
Valid parameters:
ambient_pressure, cavity_id, convection_coef, current_<x|y|z>,
diff_h_<1..10>, diff_z_e_<1..10>, diff_z_s_<1..10,
diffusion_coef, drag_coef, emp_corr_fl_fac,
emp_corr_fl_nfthp,emp_corr_fl_temp1, emp_corr_fl_temp2,
emp_corr_rr_fac, enth_ablation, enth_froz_comp, enth_pyr_twall,
enth_recovery, enth_wall_gas, flm_eff_view_fac, flm_emissivity,
flm_ext_dist_flux, flm_nat_conv_coef, flm_nat_conv_exp,
fluid_drag_factor, glocal_ext_tol, glocal_timeshift,
gradient_<x|y|z>, gravity_const, in_mass_density, in_surf_elev,
CHAPTER A 90
Arithmetic and Database Functions

Table A-2 Database Functions (continued)

Function Description
inertia_coef, init_weld_pos_<x|y|z>, liq_ph_enth_<1..10>,
liq_ph_massrt_<1..10>,nfam_particles, nliq_phases,
nterm_diffusion, out_mass_density, out_surf_elev,
part_correl_f_<1..10>, part_diameter_<1..10>,
part_enth_react_<1..10>, part_incid_ang_<1..10>,
part_massrt_<1..10>, part_velocity_x_<1..10>,
part_velocity_y_<1..10>, part_velocity_z_<1..10>, post_file_inc,
post_file_steps, pump_pressure, pyr_recession, rho_v_wall,
rot_axis_<x|y|z>1, rot_axis_<x|y|z>2, rot_axis_v<x|y|z>
sea_bed_elev, sol_abl_gas, sol_abl_liq_part, sol_abl_part_imp,
sol_massrt_eros, sol_massrt_gas, sol_massrt_part,
srf_nrg_diffusion, state_var_id, temp_inf, temp_inf_bot,
transpiration_f, view_fac_rec_inc, view_fac_rec_motion,
wave_dir_cos<1|2>, wave_height, wave_period, wave_phase,
weld_depth, weld_efficiency, weld_fwd_length,
weld_max_distance, weld_power, weld_rear_length,
weld_scale_factor, weld_surf_radius, weld_velocity, weld_width,
weldpath_offset_<x|y>
apply_dof_val(arg1,arg2) Degrees of freedom value named arg2 for the boundary condition
named arg1. If arg1 is empty, then it uses the current boundary
condition.
Example:
icond_dof_val(apply1,x)
icond_dof_val(,x)
Valid parameters:
h, kf, q, p, su, w, x1, x, y, z
apply_name( ) Returns the name of the current boundary condition.
ncbodys( ) Number of contact bodies in the database.
cbody_name_index(arg1) Contact body name of arg1-th global contact body in database.
cbody_opt(arg1,arg2) Option string for option named arg2 for contact body named arg1. If
arg1 is empty, then the current contact body is used. Option strings use
same syntax as in the *contact_option command.
Example:
cbody_opt(cbody1,wear)
91 Marc Python Reference

Table A-2 Database Functions (continued)

Function Description
cbody_par_table(arg1,arg2) Parameter table name for param named arg2 for contact body named
arg1. If arg1 is empty, then it uses the current contact body. Parameter
values use same syntax as in the *cbody_param_table command.
Example:
cbody_par_table(cbody1,filmk)
cbody_newtype(arg1) Contact body type for contact body named arg1. If arg1 is empty, then
it uses the current contact body. Function
cbody_type(arg1)should not be used anymore.
cbody_par(arg1,arg2) Parameter value named arg2 for the contact body named arg1. If arg1 is
empty, then it uses the current contact body.
Example:
cbody_par(cbody1,friction)
Valid parameters:
ac_bound_c1_inv, ac_bound_k1_inv, ax, ay, az, body_pressure,
body_voltage, brot, bx, by, bz, conductivity, contact,
contact_conductivity, contact_mass_flow_rate, cr, curve_div, cx,
cy, cz, dist_dep_conductivity, dist_dep_heat,
dist_dep_mass_flow_rate, film, friction, friction_class,
growth_factor_<x|y|z>, initvrot, initv<x|y|z>, mass_flow_rate,
natural_conv_coef, natural_conv_exp, near_contact_conductivity,
near_contact_heat, near_contact_mass_flow_rate, prot, px, py, pz,
sink_pressure, sink_voltage, spring_force, spring_lmax,
spring_lmin, spring_stiff, surf_div_u, surf_div_v,
surface_emissivity, tsink, tsurf, vrot, vx, vy, vz
cbody_class(arg1) Contact body class for contact body named arg1.
ctable_name( ) Returns the name of the current contact table.
nctables( ) Number of contact tables in the database
ctable_name_index(arg1) Contact table name of arg1-th contact table in database.
ctable_body_name_index(arg1) The name of the contact body that appears on row arg1 of a contact
table.
ctable_entry_exist(arg1,arg2,arg3) Returns 1 if an entry exists in contact table named arg1 for contact
bodies named arg2 and arg3 and returns 0 otherwise. If arg1 is empty,
then the current contact table is used.
Example:
ctable_entry_exist(ctable1,cbody1,cbody2)
CHAPTER A 92
Arithmetic and Database Functions

Table A-2 Database Functions (continued)

Function Description
ctable_opt(arg1,arg2,arg3,arg4) Option string for option named arg4 for the entry for contact bodies
named arg2 and arg3 in the contact table named arg1. If arg1 is empty,
then the current contact table is used. The contact table entry for the two
bodies must exist. Please see ctable_entry_exist() on how check
existence of the entry. Option strings use same syntax as in the
*contact_table_option command.
Example:
ctable_opt(ctable1,cbody1,cbody2,
contact_type)
ctable_par(arg1,arg2,arg3,arg4) Parameter value for parameter named arg4 for the entry for contact
bodies named arg2 and arg3 in the contact table named arg1. If arg1 is
empty, then the current contact table is used. The contact table entry for
the two bodies must exist. Please see ctable_entry_exist() on how check
existence of the entry. Parameter values use same syntax as in the
*contact_table_property command.
Example:
ctable_par(ctable1,cbody1,cbody2,friction)
ctable_par_table(arg1,arg2,arg3,arg4) Parameter table name for parameter named arg4 for the entry for contact
bodies named arg2 and arg3 in the contact table named arg1. If arg1 is
empty, then the current contact table is used. The contact table entry for
the two bodies must exist. Please see ctable_entry_exist() on how check
existence of the entry. Parameter values use same syntax as in the
*contact_table_property_table command.
Example:
ctable_par_table(ctable1,cbody1,cbody2,
friction)
niconds( ) Number of initial conditions in the database
icond_name_index(arg1) Initial condition name of arg1-th initial condition in database.
icond_opt(arg1,arg2) Option string for option named arg2 for the initial condition named
arg1. If arg1 is empty, then it uses the current initial condition. Option
strings use same syntax as in the *icond_option command.
Example:
icond_opt(icond1,dof_values)
icond_type(arg1) Initial condition type for icond arg1. If arg1 is empty, then it uses the
current initial condition.
93 Marc Python Reference

Table A-2 Database Functions (continued)

Function Description
icond_dof_val(arg1,arg2) Degrees of freedom value named arg2 for the initial condition named
arg1. If arg1 is empty, then it uses the current initial condition.
Example:
icond_dof_val(icond1,x)
icond_name( ) Returns the name of the current initial condition.
icond_par(arg1,arg2) Parameter value named arg2 for the initial condition named arg1. If arg1
is empty, then it uses the current initial condition.
Example:
icond_par(icond1,trans_x)
ngeoms( ) Number of geometric properties in the database
geom_name( ) Returns the name of the current geometric property
geom_name_index(arg1) Geometic property name of arg1-th geometry in database.
geom_opt(arg1,arg2) Option string for option named arg2 for geometry named arg1. If arg1
is empty, then it uses the current geometry. Option strings use same
syntax as in the *geometry_option command.
Example:
geom_opt(geom3,cdilatation)
geom_par(arg1,arg2) Parameter value for param named arg2 for geometry named arg1. If
arg1 is empty, then it uses the current geometry. Parameter values use
same syntax as in the *geometry_param command.
Example:
geom_par(geom3,thick)
geom_par_table(arg1,arg2) Parameter table name for value named arg2 for geometry named arg1.
If arg1 is empty, then it uses the current geometry. Parameter values use
same syntax as in the *geometry_param_table command.
Example:
geom_par_table(geom3,thick)
geom_type(arg1) Geometric property type for geometry arg1. If arg1 is empty, then it uses
the current geometry.
CHAPTER A 94
Arithmetic and Database Functions

Table A-2 Database Functions (continued)

Function Description
job_par(arg1,arg2) Parameter value named arg2 for job arg1. If arg1 is empty, then it uses
the current job.
Example:
job_par(lcase1,trans_x)
Valid parameters:
adapg_frequency, adapt_frequency, ambient_pressure,
bcond_pen_mp, bi_maxit, bi_tol, bm_bm_files_freq, condition,
conversion, cutoff, cycs_rot_axis_dir_<x|y|z>,
cycs_rot_axis_point_<x|y|z>, cycs_rot_nrepetitions,
cycs_tolerance, ddm_precond_level, ddm_sort_direction_<x|y|z>,
ddm_sort_point_<x|y|z>, ddm_tolerance, decomp_elweight_coeff,
des_act_cons, des_crit_cons, des_opt_cycles, disttol, disttolbias,
dyn_contact_pro_fact, ebe_heat_tol, ebe_maxit, ebe_stress_tol,
elec_heat_conv, fl_hardw_sparse_thresh,
flowl_grid_num_<x|y|z>, flowl_grid_pnt_<x|y|z>,
flowl_grid_siz_<x|y|z>, fluid_incomp_pen, fric_coeff_mult,
fric_force_tol, fric_heat_conv, hardw_sparse_thresh,
hemi_cube_axi_div, hemi_cube_pixels, hyper_post, id_post,
inc_strn_pred_mp, init_frict_stiff, instrain,
layers, limit_angle_<2d | 3d>, lmax, max_cont_nod,
max_cont_seg, max_el, max_fixed_dof, max_groups,
max_it_disp_comp, max_nod, maxsep, mean_strs_subtr, memory,
mi_high, mi_initshift mi_low, mi_maxfreq, mi_maxit, mi_nmodes,
mi_shiftmodes, mi_shiftpar, mi_tol, naggregates_domain,
nbmodes, ndomains, newm_beta_beta, newm_beta_gamma,
nmodes, npbmodes, pct_in_core, planck_radiation_2,
polytropic_proc_exp, post,
reauto_end, reauto_maxstep, reauto_percent, reauto_reassem,
reauto_recycles, reauto_steps, reauto_time, recess_file_freq,
rel_disp_threshold, rel_sepstress, restart, restart_time,
rp_incomp_pen, rstrt_ninc_bef_last,
sepforce, sepstress, shell_drill, si_st_hou_gamma,
si_st_hou_gamma1, singularity_thresh, slip_stick_trans,
solver_preallocation, sparse_maxit, sparse_tol,
specific_weight_<x|y|z>, speed_light_vacuum, spline_files_freq,
ss_roll_corn_axis_<dir|point>_<x|y|z>,
ss_roll_corn_axis_<dir|point>_<x|y|z>,
ss_roll_rot_axis_<dir|point>_<x|y|z>, start, state_variables,
stef_boltz, strline_file_freq,
95 Marc Python Reference

Table A-2 Database Functions (continued)

Function Description
temp_offset, thermal_prop_eval_fac, throat_axial_coord,
throat_circumf_div, throat_radial_coord, univ_gas_const,
usdata_alloc, user_nod_vects, view_fac_implic_ctff_frac,
view_fac_implic_thresh, view_fac_use_ctff_frac,
view_fac_use_thresh, vsliding
njobs( ) Number of jobs in the database.
job_class(arg1) Job class for job named arg1. If arg1 is empty, then it uses the current
job.
job_name_index(arg1) job name of arg1-th job in database.
job_opt(arg1,arg2) Option string for option named arg2 for the job named arg1. If arg1 is
empty, then it uses the current job. Option strings use same syntax as in
the *job_option command.
Example:
job_opt(job1,frictype)
nlcases( ) Number of loadcases in the database
lcase_opt(arg1,arg2) Option string for option named arg2 for the loadcase named arg1. If arg1
is empty, then it uses the current loadcase. Option strings use same
syntax as in the *loadcase_option command.
Example:
loadcase_opt(job1,stepping)
lcase_name_index(arg1) Loadcase name of arg1-th loadcase in database.
lcase_type(arg1) Loadcase type for loadcase named arg1. If arg1 is empty, then it uses the
current loadcase.
lcase_name( ) Returns the name of the current loadcase.
lcase_par(arg1,arg2) Parameter value named arg2 for loadcase arg1. If arg1 is empty, then it
uses the current loadcase.

abscurrent, angle<0..5>, anneal_temp, bcond_pen_mp,

before_bdc_<x|y|z>, beta, buckle_tol, charge, cooling_time,
Example:
lcase_par(lcase1,trans_x)
Valid parameters:
cornering_velocity, crank_length, creeptime, current, cutoff_stress,
cutter_rapid_speed, cycle_time,
CHAPTER A 96
Arithmetic and Database Functions

Table A-2 Database Functions (continued)

Function Description
d_epot_allowed, d_srec_allowed, d_xsic_allowed,
d_xsip_allowed, d_xsiv_allowed, damping_ratio, desired,
displacement, dp_allowed, dp_assemble, dp_error, dt_allowed,
dt_assemble, dt_error, duplicate_nrep, dyn_contact_pro_fact,
eccentricity, efficiency, elec_pot, finish_nds_contact, fluid_force,
fluid_incomp_pen, fluid_maxforce, fluid_maxvelo,
fluid_minforce, fluid_minvelo, fluid_velo, force, friction_force,
gamma,
ground_velocity_<x|y|z>, high, inc_assemble, inc_strain,
inc_strn_pred_mp, init_frict_stiff, initfraction, initshift, inittime,
limit_angle_<2|3>d, low, magn_pot,
mass, max_it_disp_comp, max_num_adjustments, max_step_ratio,
maxcharge, maxcurrent, maxdisp, maxelec_pot, maxforce,
maxfraction, maxinc, maxit, maxjobinc, maxmagn_pot,
maxmoment, maxmultiplier, maxnsteps, maxrec, maxrotation,
maxsubinc, maxtime, mc_dely<1..4>_<1..12>,
mc_xmax<1|2|3_<1..12>, mean_strs_subtr,
membr_pre_strs_<incs|val>, min_arcl_ratio, min_step_ratio,
mincharge, mincurrent, mindisp, minelec_pot, minforce,
minfraction, minmagn_pot, minmoment, minmultiplier, minrec,
minrotation, mintstep, moment, motion_cbody_<x|y|z><0..5>,
motion_cbody_rot<0..5>, multiblow,
nfreq, ngsteps, nmodes, npmodes, nsteps, ntime_cuts, num_post,
post_increment, press_dir_<x|y|z>, press_finish, press_max_force,
process_in1_<min|max>, process_out1_max_ctff,
process_out1_smpl_ctff, process_out1_tgt, pshigh,
ref_point_<x|y|z>, relcurrent, rod_length, rotate_<x|y|z>, rotation,
rp_ctff_strn_rt, rp_incomp_pen, rp_init_strn_rt,
scale_step, sequence, shell_drill, shiftmodes, shiftpar,
si_st_hou_gamma, si_st_hou_gamma1, singularity_thresh,
spinning_velocity, ss_rolling_tolerance, state_var_id, strain,
strain_change, stress_change, symmetry_norm_<x|y|z>, t_dist,
t_dist_bodys, t_force, t_nodes, t_stroke, temp_change,
temp_finish, thermal_prop_eval_fac, time, time<1..5>, tolerance,
torque, tot_energy, translate_<x|y|z>, transport_time,
univ_gas_const, vel_def, vel_in, vel_out, weight_d<x|y|z>,
weight_r<x|y|z>
lcase_title( ) Returns the title of the current loadcase.
nmaters( ) Number of materials in the database.
97 Marc Python Reference

Table A-2 Database Functions (continued)

Function Description
mater_id(arg1) Returns the ID of the material named arg1 or of the current material if
arg1 is empty
mater_name( ) Returns the name of the current material in the database
mater_name_index(arg1) Material name of arg1-th material in database.
mater_opt(arg1,arg2) Option string for option named arg2 for material named arg1. If arg1 is
empty, then it uses the current material. Option strings use same syntax
as in the *mater_option command.
Example:
mater_opt(material3,structural:type)
mater_par(arg1,arg2) Parameter value for param named arg2 for material named arg1. If arg1
is empty, then it uses the current material. Parameter values use same
syntax as in the *mater_param command.
Example:
mater_par(material3,structural:youngs_ modulus)
mater_par_table(arg1,arg2) Parameter table name for value named arg2 for material named arg1. If
arg1 is empty, then it uses the current material. Parameter values use
same syntax as in the *mater_param_table command.
Example:
mater_par_table(material3,structural: youngs_modulus)

mater_type(arg1) Material type for material named arg1. If arg1 is empty, then it uses the
current material.
mater_nsubmats(arg1) Number of submaterials of material named arg1, or of the current
material is arg1 is empty. The material must be a composite, mixture or
rebar material.
mater_vsubmat_name(arg1,arg2) Name of submaterial number arg2 of materal named arg1, or of the
current material if arg1 is empty. Material arg1 (or the current material
if arg1 is empty) must be a composite, mixture or rebar material.
mater_vsubmat_opt(arg1,arg2,arg3) Option string for the option named arg3 for submaterial number arg2 of
material named arg1, or of the current material if arg1 is empty. Material
arg1 (or the current material if arg1 is empty) must be a composite,
mixture or rebar material. Option argument uses same syntax as in the
*mater_submat_option command.
Example:
mater_vsubmat_opt(material3,5,general:thickdir)
CHAPTER A 98
Arithmetic and Database Functions

Table A-2 Database Functions (continued)

Function Description
mater_vsubmat_par(arg1,arg2,arg3) Value of parameter named arg3 for submaterial number arg2 of material
named arg1, or of the current marterial if arg1 is empty. Material arg1
(or the current material if arg1 is empty) must be a composite, mixture
or rebar material. Parameter argument uses same syntax as in the
*mater_submat_param command.
Example:
mater_vsubmat_par(material3,6,general:compos_ply_thick_percent)

mater_vsubmat_par_table(arg1,arg2,arg3) Returns the parameter table name for the parameter named arg3 for
submaterial number arg2 or the material named arg1, or of the current
marterial if arg1 is empty. Material arg1 (or the current material if arg1
is empty) must be a composite, mixture or rebar material. Parameter
argument uses same syntax as in the
*mater_submat_param_table command.
mater_fsubmat_name(arg1,arg2) Name of submaterial arg2 of material named arg1, or of the current
marterial if arg1 is empty. Material arg1 (or the current material if arg1
is empty) must be an interface, gasket, pshell or pyrolysis material. The
submaterial argument arg2 takes the same values as the first argument
to the *mater_submat_set_mater command.
Example:
mater_fsubmat_name(material3,bend)
mesh_par(arg1) Meshing parameter value named arg1.
Example:
mesh_par(qt_max_elements)
Valid parameters:
angle_cylindrical_part, attempts, axis_orientation,
base_element_size_<x|y|z>, boundary_refine_level,
boundary_refine_tolerance, box_<1...10>_max_<x|y|z>,
box_<1...10>_min_<x|y|z>, box_<1...10>_active,
box_<1...10>_type, box_<1...10>_level, critical_ring_angle,
coarsening_level, coon_representation, curvature_tolerance,
edge_detection, edge_angle, edge_length, el_gap, edge_tolerance,
enhance_mode, hex_elements, gap, grid_type, in_rat, mesher_type,
self_contact, shrink_factor, ties, write_extended
99 Marc Python Reference

Table A-2 Database Functions (continued)

Function Description
pm_par(arg1) Returns parameter string named arg1.
Example:
pm_par(arg1)
Example:
*define aa MyText
pm_par(aa)
pr_par(arg1) Program data parameter value named arg1.
Example:
pr_par(curve_div_maxl)
Valid parameters:
curve_div_<maxl|minl|type|ndiv|tol|rest>, curve_div_tol_abs,
mesh_cv_div_avgl, mesh_<min|max|param>_tol, intersect_tol,
relative_tol, sweep_tolerance, overlay_ndiv_<x|y>
nlinks( ) Number of links of any class in the database
nservos( ) Number of links of class servo in the database
nsprings( ) Number of links of class spring in the database
nties( ) Number of links of class tie in the database
link_class(arg1) Link type name for link arg1. One of: servo, spring, tie. If arg1 is empty,
then it uses the current link.
tie_type(arg1) Tie type name for tie arg1. If arg1 is empty, then it uses the current tie.
link_name_index(arg1) Link name of arg1-th link in database.
link_name( ) Returns the name of the current link.
tie_name () Returns the name of the current tie.
servo_name( ) Returns the name of the current servo.
spring_name( ) Returns the name of the current spring.
spring_par(arg1) Spring parameter value named arg1 for the current spring.
Example:
spring_par(damping)
Valid parameters:
conductivity, current, damping, dynamic_force, flux, heat,
init_force, static_forcet, stiffness
CHAPTER A 100
Arithmetic and Database Functions

Table A-2 Database Functions (continued)

Function Description
spring_par_table(arg1,arg2) Spring table name for value named arg2 for lin named arg1. If arg1 is
empty, then it uses the current spring. Parameter values use same syntax
as in the *spring_param_table command.
Example:
spring_par_table(link2,stiffness)
spring_opt(arg1,arg2) Option string for option named arg2 for spring named arg1. If arg1 is
empty, then it uses the current spring. Option strings use same syntax as
in the *spring_option command.
Example:
geom_opt(link2,spring_type)
norients( ) Number of orientations in the database
orient_name( ) Returns the name of the current orientation.
orient_name_index(arg1) Orientation name of arg1-th orientation in database.
orient_type(arg1) Orientation type for orientation arg1. If arg1 is empty, then it uses the
current orientation.
orient_opt(arg1,arg2) Option string for option named arg2 for orientation named arg1. If arg1
is empty, then the current orientation is used. Option strings use same
syntax as in the *orient_option command.
Example:
orient_opt(orientation1,reverse_curves)
orient_par(arg1,arg2) Parameter value for parameter named arg2 for orientation named arg1.
If arg1 is empty, then the current orientation is used. Parameter values
use same syntax as in the *orient_param command.
Example:
orient_par(orientation1,rx)
ntforms( ) Number of transforms in the database
tform_name( ) Returns the name of the current transform.
tform_name_index(arg1) Transform name of arg1-th transform in database.
tform_opt(arg1,arg2) Option string for option named arg2 for transform named arg1. If arg1
is empty, then it uses the current transform. Option strings use same
syntax as in the *transform_option command.
Example:
tform_opt(tform2,method)
table_name( ) Returns the name of the current table.
101 Marc Python Reference

Table A-2 Database Functions (continued)

Function Description
wz_par(arg1) SuperForm Wizard parameter value named arg1.
Example:
wz_par(length)
Valid parameters:
angle, diam, elmax, elmin, fric, fric_class, heatcoef, height, length,
mvx, mvy, mvz, num, rep, rotx, roty, rotx, temp, thick, type1, type2,
type3, type4, width
wz_str(arg1) SuperForm Wizard string value named arg1.
Example:
wz_str(tool_name)
Valid parameters:
die, cat_string, tool_name, workpiece, wp_name

Utility Functions
The following are the Mentat Utility Functions which can be used in the py_get_float, py_get_int, or
py_get_string functions.

Table A-3 Utility Functions

Function Description
range(arg1,arg2,arg3) Generates a string list of integer items that can be used as a pick list.
Definitions:
arg1 - start number
arg2 - end number
arg3 - increment
If arg1 < arg2, then the list is generated in reverse.
For example:
range(10,26, 4)
will return “10 14 18 22 26”.
Example usage:
*add_nodes 3 4 range(10,26,4)
range2(arg1,arg2) Same as range except that arg3 (the increment value) is set as 1.
element_aspect_ratio(arg1) Aspect ratio of element arg1 as computed by the *check_aspect
command
CHAPTER A 102
Arithmetic and Database Functions

Table A-3 Utility Functions (continued)

Function Description
element_distortion(arg1) Distortion factor of element arg1 as computed by the
*check_distorted command
element_inside_out(arg1) Returns 1 if element arg1 is inside out; 0 otherwise
element_upside_down(arg1) Returns 1 if element arg1 is upside down; 0 otherwise
element_attach_curve(arg1, arg2) Returns the ID of the curve to which the arg2-th edge of element arg1 is
attached, 0 otherwise
element_attach_surface(arg1, arg2) Returns the ID of the surface to which the arg2-th face of element arg1 is
attached; 0 otherwise
node_point_id(arg1) Returns the ID of the point to which the node arg1 is attached, 0 otherwise
curve_x(arg1, u) X coordinate of a point on curve arg1 with natural coordinate u
curve_y(arg1, u) Y coordinate of a point on curve arg1 with natural coordinate u
curve_z(arg1, u) Z coordinate of a point on curve arg1 with natural coordinate u
surface_x(arg1, u, v) X coordinate of a point on surface arg1 with natural coordinates <u>,<v>
surface_x(arg1, u, v) Y coordinate of a point on surface arg1 with natural coordinates <u>,<v>
surface_x(arg1, u, v) Z coordinate of a point on surface arg1 with natural coordinates <u>,<v>
global_x(ux, uy, uz) Transform the user coordinates (<ux>,<uy>,uz>) to the global
coordinate system and return the X coordinate.
global_y(ux, uy, uz) Transform the user coordinates (<ux>,<uy>,uz>) to the global
coordinate system and return the Y coordinate.
global_z(ux, uy, uz) Transform the user coordinates (<ux>,<uy>,uz>) to the global
coordinate system and return the Z coordinate.
user_def(arg1) Returns the user defined data at the specified index arg1 that was set with the
user_defined_data command.
user_x(gx, gy, gz) Transform the global coordinates (<gx>,<gy>,gz>) to the current user
coordinate system and return the X coordinate.
user_x(gx, gy, gz) Transform the global coordinates (<gx>,<gy>,gz>) to the current user
coordinate system and return the Y coordinate.
user_x(gx, gy, gz) Transform the global coordinates (<gx>,<gy>,gz>) to the current user
coordinate system and return the Z coordinate.

Post File Database Functions

The following are the Marc Post File Database Functions which can be used in the py_get_float, py_get_int,
or py_get_string functions.
103 Marc Python Reference

Table A-4 Post File Database Functions

Function Description
displace_x(arg1) Global X displacement of node arg1.
displace_y(arg1) Global Y displacement of node arg1.
displace_z(arg1) Global Z displacement of node arg1.
post_data(name) Returns the value for name, which is a string argument. It can be the name of any
PyPost attribute except for filename or extrapolate.
For example:
post_data(work)
post_data(time)
post_increments( ) If a post file is opened, it returns the number of increments in the post file.
post_node_extra(arg1) Returns 1 if node arg1 is an extra (dummy) node; 0 if a valid node.
scalar_1(arg1) First scalar component of node arg1
scalar_2(arg1) Second scalar component of node arg1
scalar_max_element( ) Returns the first element in which the scalar quantity is the maximum value.
scalar_min_element( ) Returns the first element in which the scalar quantity is the minimum value.
scalar_max_node( ) Returns the first node in which the scalar quantity is the maximum value.
scalar_min_node( ) Returns the first node in which the scalar quantity is the minimum value.
scalar_pos(x,y,z) Returns the value of the scalar quantity that is being postprocessed at position (x,y,z),
if that position is located somewhere in the finite element mesh or 0 if the position is
outside the finite element mesh. The value is obtained by interpolating the closest
element.
vector_x(arg1) Vector X value of node arg1. This can be a post file value or a value calculated from
*geomdist_surfaces or other vector creation commands.
vector_y(arg1) Vector Y value of node arg1. This can be a post file value or a value calculated from
*geomdist_surfaces or other vector creation commands.
vector_z(arg1) Vector Z value of node arg1. This can be a post file value or a value calculated from
*geomdist_surfaces or other vector creation commands.
add_disp(arg1, arg2) Increments (adds to) the global X,Y,Z displacement of node arg1 by arg2. If the node
number arg1 is -1, then it increments the global displacement X,Y,Zof all the nodes. If
the node number arg1 is zero, then it increments the global X,Y,Z displacement of the
selected nodes.
add_displ_x(arg1, arg2) Increments the global X displacement of node arg1 by arg2. If the node number arg1 is
-1, then it increments the global displacement X of all the nodes. If the node number
arg1 is zero, then it increments the global X displacement of the selected nodes.
CHAPTER A 104
Arithmetic and Database Functions

Table A-4 Post File Database Functions (continued)

Function Description
add_displ_y(arg1, arg2) Increments the global Y displacement of node arg1 by arg2. If the node number arg1 is
-1, then it increments the global displacement Y of all the nodes. If the node number
arg1 is zero, then it increments the global Y displacement of the selected nodes.
add_displ_z(arg1, arg2) Increments the global Zdisplacement of node arg1 by arg2. If the node number arg1 is
-1, then it increments the global displacement Zof all the nodes. If the node number
arg1 is zero, then it increments the global Z displacement of the selected nodes.
scale_disp(arg1, arg2) Scales the global X,Y,Z displacement of node arg1 by arg2. If the node number arg1 is
-1, then it scales the global displacement X,Y,Zof all the nodes. If the node number arg1
is zero, then it scales the global X,Y,Z displacement of the selected nodes.
scale_displ_x(arg1, arg2) Scales the global X displacement of node arg1 by arg2. If the node number arg1 is -1,
then it scales the global displacement X of all the nodes. If the node number arg1 is
zero, then it scales the global X displacement of the selected nodes.
scale_displ_y(arg1, arg2) Scales the global Y displacement of node arg1 by arg2. If the node number arg1 is -1,
then it scales the global displacement Y of all the nodes. If the node number arg1 is
zero, then it scales the global Y displacement of the selected nodes.
scale_displ_z(arg1, arg2) Scales the global Zdisplacement of node arg1 by arg2. If the node number arg1 is -1,
then it scales the global displacement Zof all the nodes. If the node number arg1 is zero,
then it scales the global Z displacement of the selected nodes.
set_displace_x(arg1, arg2) Sets the global X displacement of node arg1 to arg2.
set_displace_y(arg1, arg2) Sets the global Y displacement of node arg1 to arg2.
set_displace_x(arg1, arg2) Sets the global Z displacement of node arg1 to arg2.

Set Functions
The following are the Mentat Set functions which can be used in a call to the py_get_float or py_get_int
functions. The set_name and set_type functions return a string and must be used in a call to the
py_get_string function.

Table A-5 Set Functions

Function Description
is_curve_set(arg1) Returns 1 if set arg1 is a curve set, 0 otherwise.
is_edge_set(arg1) Returns 1 if set arg1 is a edge set, 0 otherwise.
is_element_set(arg1) Returns 1 if set arg1 is a element set, 0 otherwise.
is_face_set(arg1) Returns 1 if set arg1 is a face set, 0 otherwise.
is_node_set(arg1) Returns 1 if set arg1 is a node set, 0 otherwise.
105 Marc Python Reference

Table A-5 Set Functions (continued)

Function Description
is_point_set(arg1) Returns 1 if set arg1 is a point set, 0 otherwise.
is_surface_set(arg1) Returns 1 if set arg1 is a surface set, 0 otherwise.
nsets( ) Number of sets in database
nset_entries(arg1) Number of set entries for set arg1
set_edge(arg1, arg2) The ID of the arg2-th edge set entry in edge set arg1.
set_entry(arg1, arg2) The value of the arg2-th set entry in set arg1.
set_face(arg1, arg2) The ID of the arg2-th face set entry in face set arg1.
set_id(ARG1) ID of arg1-th set in database
set_name(arg1) Name of set arg1. This is a string value, and can only be used in py_get_string.
set_type(arg1) Type of set arg1. This is a string value, and can only be used in py_get_string. Returned
values will be one of the following strings: node, element, point, edge, curve, face, surface.