Marc Python 2013.

1
Tutorial and Reference Manual

Corporate
MSC.Software Corporation 4675 MacArthur Court, Suite 900 Newport Beach, CA 92660 Telephone: (714) 540-8900 Toll Free Number: 1 855 672 7638 Email: [email protected]

Europe, Middle East, Africa

MSC.Software GmbH Am Moosfeld 13 81829 Munich, Germany Telephone: (49) 89 431 98 70 Email: [email protected]

Japan
MSC.Software Japan Ltd. Shinjuku First West 8F 23-7 Nishi Shinjuku 1-Chome, Shinjuku-Ku Tokyo 160-0023, JAPAN Telephone: (81) (3)-6911-1200 Email: [email protected]

Asia-Pacific
MSC Software (S) Pte. Ltd. 100 Beach Road #16-05 Shaw Tower Singapore 189702 Telephone: 65-6272-0082 Email: [email protected]

Worldwide Web
www.mscsoftware.com
User Documentation: Copyright 2013 MSC Software Corporation. Printed in U.S.A. All Rights Reserved. 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., MD 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. LS-DYNA is a trademark of Livermore Software Technology Corporation. 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. METIS is copyrighted by the regents of the University of Minnesota. HP MPI is developed by Hewlett-Packard Development Company, L.P. MS MPI is developed by Microsoft Corporation. PCGLSS 6.0, copyright 1992-2005 Computational Applications and System Integration Inc. MPICH Copyright 1993, University of Chicago and Mississippi State University. MPICH2 copyright 2002, University of Chicago. 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*V2013.1*Z*Z*Z*DC-PYTH

Contents
Marc Python Tutorial and Reference Manual
Marc Python Tutorial

Marc Python Tutorial Preface

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Organization of this Manual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Contents of the Chapters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Documentation Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Introduction

Welcome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 The Basics of Using PyMentat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 The Basics of Using PyPost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 A Brief Look at Python Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 Python Data Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

PyMentat: A Simple Example

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 Creating a Simple Python Script for Mentat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 Python Programming Hints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 Running the Script. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

4 Marc Python Tutorial and Reference Manual

PyMentat: Obtaining Data from Mentat

27 27 28 29

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating a Simple Python Script for Mentat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The py_get_int and py_get_float Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

PyMentat: Building Complex Geometry

31 31 34

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Background Information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

PyMentat: Adding Model Properties

37 37 41 42 44

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Plate Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Node and Element IDs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Submitting the Job . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

PyMentat: Processing a Post File

46 46 50 50

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Postprocessing Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Scalar Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

PyMentat: Obtaining Model Data

52 52

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Database Properties Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Contents 5

Set Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A Sample Script to Extract Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Set IDs and Set Names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

53 53 58 62

PyPost: Reading a Post File

64 64 66

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . PyPost Basics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

PyPost: Obtaining Element Data

69 69 73

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Processing Element Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

10 PyPost: Element Tensor Data

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Processing Element Tensor Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 76 79

11

PyMentat: Using the py_connect Method

81 81 81 82 83

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating a Simple Python Script for Marc Mentat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The py_connect Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Handling Socket Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6 Marc Python Tutorial and Reference Manual

12 PyPost: Plotting
Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Charting Script for Mentat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Gnuplot Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The PyOpenGL Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 86 89 93

13 PyMentat: Menu System Lookup Functions

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Menu System Lookup Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Integer Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Double Function. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . String Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Boolean Function. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . State Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 104 105 105 105 106 107

14 MentatDCOM: Connecting to Mentat using a .NET Module

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MentatDCOM Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Running the Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MentatDCOM and PyMentat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 112 115 116

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

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MarcPost Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Running the Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MarcPost and PyPost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 119 122 123

Contents 7

Marc Python Reference Introduction

Using the Python Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Variable Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 3

PyMentat References
5

PyMentat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

PyPost References
21

PyPost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Arithmetic and Database Functions

80 80 81 98 99 101

Introduction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Arithmetic Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Database Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Utility Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Post File Database Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Set Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

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 Part II introduces the user to the PyMentat module. This module interacts with Mentat to create, modify, and post process models. 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 PART I
PyMentat: A Simple Example PyMentat: Obtaining Data from Mentat PyMentat: Building Complex Geometry PyMentat: Adding Model Properties

provides information on the basics using PyMentat and of Python programming. PyMentat Module describes a basic PyMentat script. expands on the common features of PyMentat and describes how a Python script can get data from Mentat. displays how you can build complex geometry that cannot be done with procedure files alone. 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. shows how to process a Marc post file. shows how to write PyMentat scripts to work with SETS.

PyMentat: Processing a Post File PyMentat: Sets

11
Preface

PART II
PyPost: Reading a Post File PyPost: Obtaining Element Data PyPost: Element Tensor Data

PyPost Module introduces the basics of using the PyPost module to obtain post file data and find the maximum scalar values. shows how to obtain element scalar data from a post file. expands on obtaining element data by showing how to obtain element tensor data from a post file. It also introduces the PyTensor class. Advanced Discussions environment.

PART III

PyMentat: Using the py_connect Method introduces the basics of using the PyMentat module in a client/server 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 "\".

12 Marc Python Tutorial

Chapter 1: Introduction

Introduction

Welcome

14 14 16 17

The Basics of Using PyMentat The Basics of Using PyPost

A Brief Look at Python Programming

14 Marc Python Tutorial

Welcome
Welcome to Python a set of APIs 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.

CHAPTER 1 15 Introduction

GENERATE TEST MODEL

RUN py_create.py USING MENTAT.PROC TO CREATE INITIAL PYTHON SCRIPT

mentat.proc is created when Mentat is run

DEVELOP AND MODIFY PYTHON SCRIPT

Add new commands as 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.

16 Marc Python Tutorial

#!/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 close dies domains element elements element_id element_scalar element_scalars element_scalar_label element_sequence element_tensor element_tensors Description Closes a currently open post file and frees any allocated memory. Returns the number of dies in the post file. Returns the number of domains stored in the post file. Returns the element data for a particular element. Returns the number of elements in the current increment. Returns the id of a particular element. Returns a list of a particular element scalar data for a particular element. Returns the number of element scalars available. Returns the name of a particular element scalar. Returns the index number of a particular element ID. Returns a list of a particular element tensor for a particular element. Returns the number of element tensors available.

CHAPTER 1 17 Introduction

Function element_tensor_label element_vector element_vectors element_vector_label extrapolation increments moveto node nodes node_displacement node_displacements node_id node_scalar node_scalars node_scalar_label node_sequence node_vector node_vectors node_vector_label post_open set sets title

Description Returns the name of a particular element tensor. Returns a list of a particular element vector data for a particular element. Returns the number of element vectors available Returns the name of a particular element vector. Sets the integration point extrapolation method. Returns the number of increments available in the post file Move to a specified increment in the post file Returns the nodal data for a particular node. Returns the number of nodes for the current increment. Returns the nodal displacement values for a particular node. Returns a 1 if nodal displacements are present in the post file, 0 otherwise. Returns the ID of a particular node Returns the value of a particular node scalar for a particular node. Returns the number of node scalars available. Returns the name of a particular node scalar. Returns the index number of a particular node ID Returns the value of a particular node vector at a particular node. Returns the number of node vectors available. Returns the name of a particular node vector. Opens a post file and returns the PyPost object of it. Returns the data for a particular set. Returns the number of sets in the post file. 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.

18 Marc Python Tutorial

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 dont explicitly declare a variables data type. Python determines the data type by how the variable is used. Python supports the following implied data types: Basic Data Types
string float

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. A floating point number similar to the double data type in C and the real*8 data type in FORTRAN. FORTRAN.

integer An integer or fixed point number similar to the long int data type in C and the integer*8 data type in

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.

CHAPTER 1 19 Introduction

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

PyMentat: A Simple Example

Chapter Overview

21 21

Creating a Simple Python Script for Mentat Python Programming Hints Running the Script 23 23

CHAPTER 2 21 PyMentat: A Simple Example

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. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. return y= ys z = 0.0 delx = 1.0/s dely = 1.0/t for i in range(0,t): x = xs for j in range(0,s): str = "*add_nodes %f %f %f" % (x, y, z) py_send(str) x = x + delx y = y + dely

22 Marc Python Tutorial

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

CHAPTER 2 23 PyMentat: A Simple Example

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 Pythons % operator. It is used on string objects, and works much like Cs 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. 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. The main routine sets the size of the grid and the starting position.

Lines 18-31

Lines 33-40

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.

24 Marc Python Tutorial

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.

CHAPTER 2 25 PyMentat: A Simple Example

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 Mentat

Chapter Overview

27 27 28

Creating a Simple Python Script for Mentat The py_get_int and py_get_float Methods Running the Script 29

CHAPTER 3 27 PyMentat: Obtaining Data from Mentat

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. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. # Create the element grid 18. def make_elements(n,m): 19. 20. 21. 22. 23. 24. for i in range(1,m): n1 = (i-1) * (n) + 1 n2 = n1 + 1 n4 = n1 + (n) n3 = n2 + (n) for j in range(1,n): # the "x" dir # the "y" dir return y= ys z = 0.0 delx = 1.0/s dely = 1.0/t for i in range(0,t): x = xs for j in range(0,s): str = "*add_nodes %f %f %f" % (x, y, z) py_send(str) x = x + delx y = y + dely

28 Marc Python Tutorial

25. 26. 27. 28. 29. 30. 31. 32. 33. def main(): 34. 35. 36. 37. 38. 39. 40. return

str = "*add_elements %d %d %d %d" (n1,n2,n3,n4) py_send(str) n1 = n1 + 1 n2 = n2 + 1 n3 = n3 + 1 n4 = n4 + 1

n = py_get_int("x_size") m = py_get_int("y_size") xs = py_get_float("x_start") ys = py_get_float("y_start") make_nodes(n,m,xs,ys) make_elements(n,m)

41. if __name__ == __main__: 42. 43. 44. Lines 2-31 Lines 33-39 py_connect("",40007) main() py_disconnect() The make_nodes and make_elements routines are the same as in the previous chapter. 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. 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.

Lines 41-44

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

CHAPTER 3 29 PyMentat: Obtaining Data from Mentat

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 Mentats 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 Geometry

Chapter Overview

31 31

Background Information Running the Script 34

CHAPTER 4 31 PyMentat: Building Complex Geometry

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 Mentats user-defined menu to present a simple menu for controlling the models 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.
Y

d t=.75

height

d s d

d X

width

Figure 4-1

Plate with varying Number of Holes

32 Marc Python Tutorial

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. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. def build_plate(xstart,ystart,width, height, diameter, spacing): 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. add_plate(xs,ys,width,height) xs = .5 * (width - f * (nx - 1)) + xstart ys = .5 * (height - f * (ny - 1)) + ystart py_send("*set_curve_type circle_cr") py_send("*add_curves") r = diameter / 2 f = diameter+spacing nx = int((width-spacing)/f) ny = int((height-spacing)/f) if (nx < 1 or ny < 1 ): print "Holes are too big!" return 1 print "creating hole grid of ",nx, " by ",ny py_send("*set_curve_type line") py_send("*add_points") py_send("%f %f 0" % (xs, ys)) py_send("%f %f 0" % (xs+width, ys)) py_send("%f %f 0" % (xs+width, ys+height)) py_send("%f %f 0" % (xs, ys+height)) py_send("*set_curve_type line") py_send("*add_curves") py_send("1 2") py_send("2 3") py_send("3 4") py_send("4 1") py_send("*fill_view") return

CHAPTER 4 33 PyMentat: Building Complex Geometry

33. 34. 35. 36. 37. 38. 39.

for i in range(0, ny) : y = ys + i * f for j in range(0, nx) : x = xs + j * f py_send("%f %f 0 %f" % (x, y, r)) return 0

40. def main(): 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. if __name__ == __main__: 51. 52. Lines 2-16 py_connect("127.0.0.1",40007) main( ) 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. 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. 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. If run in a separate process, make a socket connection to Mentat. width = py_get_float("width") height = py_get_float("height") diameter = py_get_float("diameter") spacing = py_get_float("spacing") xstart = -width/2 ystart = -height/2 build_plate(xstart,ystart,width, height, diameter, spacing) return

Lines 18-38

Lines 40-48

Lines 50-52

34 Marc Python Tutorial

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.

CHAPTER 4 35 PyMentat: Building Complex Geometry

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 Properties

Chapter Overview Plate Properties

37 37 41

Node and Element IDs Running the Script Submitting the Job 42 44

CHAPTER 5 37 PyMentat: Adding Model Properties

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 Youngs modulus E = 30e6 and Poissons 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 t=.75

height

fixed

s
d d d X

width

Figure 5-1

Plate with Varying Number of Holes

38 Marc Python Tutorial

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. 82. 83. 84. 85. 86. 87. 88. def mesh_plate(width, height, diameter, spacing): 89. 90. 91. 92. 93. 94. 95. 96. def add_bc(xs,ys,width,height): 97. 98. 100. 101. 102. 103. 104. 105. 106. 107. 108. 109. 110. node_list = [] for i in range(1,n+1): str = "node_x(%d)" % i f = py_get_float(str) if check_tol(f, xs, .001): node_list.append(i) py_send("*renumber_all") n = py_get_int("nnodes()") py_send("*apply_type fixed_displacement") py_send("*apply_dof x") py_send("*apply_dof y") py_send("*apply_dof z") py_send("*set_curve_div_type_fix_avgl") l = spacing/2.0 py_send("*set_curve_div_avgl %f" % l) py_send("*apply_curve_divisions all_existing") py_send("*dt_planar_trimesh all_existing") return return 0 if f1 == f2: return 1 if f1 + tol < f2: if f1 - tol > f2: return 1

99. # add fixed bc at left edge

CHAPTER 5 39 PyMentat: Adding Model Properties

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

117. # add edge load at top

40 Marc Python Tutorial

145. 146. def main(): 147. 148. 149. 150. 151. 152. 153. 154. 155. 156. 157. 158. 159. 160. 161. 162. if __name__ == __main__: 163. 164. 165. 166. Lines 2-8 Lines 10-17 Lines 19-46 The check_tol routine is a convenience function to compare two floating point number for equality within a certain tolerance. 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. 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 its position in the X direction. If a match is found, we obtain the node ID (which may be different from its 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). py_connect("",40007) main() py_disconnect() xs = 0.0 ys = 0.0 width = py_get_float("width") height = py_get_float("height") diameter = py_get_float("diameter") spacing = py_get_float("spacing") build_plate(xs,ys,width, height, diameter, spacing) mesh_plate(width, height, diameter, spacing) add_bc(xs,ys,width, height) add_matl() add_geom_prop() add_job() py_send("save_as_model chap5.mfd yes") return

CHAPTER 5 41 PyMentat: Adding Model Properties

Lines 48-52 Lines 54-61 Lines 63-67 Lines 69-83

The add_matl routine applies the material properties to all the elements of the plate. The add_job routine creates the necessary job parameters. The add_geom_prop routine applies the necessary geometric properties. 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.

42 Marc Python Tutorial

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

CHAPTER 5 43 PyMentat: Adding Model Properties

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

44 Marc Python Tutorial

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 File

Chapter Overview

46 46

Postprocessing Basics Scalar Values 50 50

Running the Script

46 Marc Python Tutorial

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. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. max_scalars = [] n = py_get_int("nnodes()") label = [] label.append("*post_value Displacement x") label.append("*post_value Displacement y") label.append("*post_value External Force x") label.append("*post_value External Force y") label.append("*post_value Reaction Force x") label.append("*post_value Reaction Force y") # get number of nodes py_send("*post_close") py_send("*post_open chap6_job1.t16") py_send("*post_next") py_send("*fill_view") py_send("*post_contour_lines")

CHAPTER 6 47 PyMentat: Processing a Post File

20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52.

max_nodes = [] for i in range(0,6): max_scalars.append(0.0) max_nodes.append(0) str = "*post_value " + label[i] py_send(str) j = 1 while j <= n: str = "node_id(%d)" % j n_id = py_get_int(str) str = "post_node_extra(%d)" % n_id flag = py_get_int(str) if flag == 0: # check for valid post node str = "scalar_1(%d)" % n_id f = py_get_float(str) if f < 0.0: f = -f if f > max_scalars[i] max_scalars[i] = f max_nodes[i] = n_id j = j + 1 py_send("*draw_legend off") py_send("*unpost_nodes all_existing") py_send("*post_nodes ") print " Label node scalar"

print " ------------------------------------------" for i in range(0,nns): j = max_nodes[i] str = " %18s %10i %g" % (label[i], p.py_node_id(j),max_scalars[i]) print str

48 Marc Python Tutorial

53. 54. 55. 56. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. 69. 70. 71. 72. 73. 74. 75. 76. 77.

py_send( max_nodes[i] ) py_send(" #") py_send("*post_numerics") return print " " print " Label node scalar" print " ------------------------------------------" for i in range(0,len(label)): str = "*post_value " + label[i] py_send(str) str = "node_id(%d)" % j n_id = py_get_int("scalar_max_node()") str = "scalar_1(%d)" % n_id d = py_get_float(str) n_id2 = py_get_int("scalar_min_node()") str = "scalar_1(%d)" % n_id f = py_get_float(str) if d < -f: d = -f n_id = n_id2 str = " %18s %10i print str return %g" % (label[i],n_id, d)

57. # Use database functions to find max/min

78. if __name__ == '__main__': 79. 80. 81. Lines 4-7 Line 8 py_connect('',40007) main() py_disconnect() 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. We need to tell Mentat that we are working with scalar values, so one of the SCALAR PLOT commands need to be sent.

CHAPTER 6 49 PyMentat: Processing a Post File

Line 10 Lines 11-17

This statement will get the number of nodes in the model. Note that this number may change at different increments due to rezoning. 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. 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. The loop for all of the scalars in our list. 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. Specify the scalar name to use. 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. Obtain the node ID for this node. 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. Obtain the scalar value using the Database function scalar_1. We will use only positive values. If it is negative, then change it to positive. Check the current value against the highest value in our list. Turn off the legend. 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. Start the *select_node command. Print out the results for each scalar. 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. Send the # symbol to signify End of List. Turn on NUMERICS. 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.

Lines 19-20

Lines 21 Lines 22-23 Lines 24-25 Lines 28

Lines 29-30 Lines 31-32

Lines 33-34 Lines 35-36 Lines 37-39 Line 43 Lines 44-45

Line 43 Lines 47-52 Line 53 Line 54 Line 55 Line 58-76

50 Marc Python Tutorial

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

PyMentat: Obtaining Model Data

Chapter Overview

52 52

Database Properties Basics Set Basics 53

A Sample Script to Extract Data Running the Script 58 62

53

Set IDs and Set Names

52 Marc Python Tutorial

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 Mentats database. Mentat has functions that supports the following items:
adapg apply cbody ctable geom icond material lcases jobs

Global adaptive remeshing criteria. Boundary condition properties. Contact body data. Contact table data Geometric properties. Initial condition properties. Material properties. Loadcase data. 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 element_geom element_material element_orient

Name of contact body that the element belongs. Name of the geometric property that the element belongs. Name of the material property that the element belongs. Name of the orientation property that the element belongs.

CHAPTER 7 53 PyMentat: Obtaining Model Data

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 element point curve surface edge face

The set contains the node IDs of its entries. The set contains the element IDs of its entries. The set contains the point IDs of its entries. The set contains the curve IDs of its entries. The set contains the surface IDs of its entries. The set contains the element IDs and the edge number of its entries. 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. 4. 5. 6. 7. m = py_get_int("nsets()") print "Found ",m," sets" py_send("*new_model yes *open_model sets.mfd")

54 Marc Python Tutorial

8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40.

for i in range(1,m+1): id = py_get_int("set_id(%d)" % i) sn = py_get_string("set_name(%d)" % id) st = py_get_string("set_type(%d)" % id) n = py_get_int("nset_entries(%d)" % id) if stype not in ("icond","apply","lcase"): print "Set ",sn,"is a ",stype," set with ",n,"entries" for j in range(1,n+1): k = py_get_int("set_entry(%d,%d)" % (id, j)) print " entry ",j," is ",k, if (stype == 'face'): l = py_get_int("set_edge(%d,%d)" % (id, j)) print " face number ",l elif(stype == 'edge'): l = py_get_int("set_edge(%d,%d)" % (id, j)) print " else: print " " print " " m = py_get_int("ncbodys()") print "Found ",m," Contact Bodys" for i in range(1,m+1): sn = py_get_string("cbody_name_index(%d)" % i) id = py_get_int("cbody_id(%s)" % sn) print " Contact Body ", i, " Id ",id, " Name ", sn edge number ",l

m = py_get_int("nmaterials()") print "\n Materials ",m for i in range(1,m+1): sn = py_get_string("material_name_index(%d)" % i) st = py_get_string("material_type(%s)" % sn)

CHAPTER 7 55 PyMentat: Obtaining Model Data

41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. 69. 70. 71. 72. 73.

= py_get_float("material_par (%s,isotropic:youngs_modulus)" % sn) Material %14s Type %19s Young's Mod %g" % (sn,st,p)

str = " print str mt st

= py_get_string("material_opt( %s,plasticity:method)" % sn) = py_get_string("material_opt( %s,plasticity:yield)" % sn) Plasticity method %9s Yield Surface %s" % (mt, st)

str = " print str

m = py_get_int("napplys()") print "\n Boundary Conditions ",m for i in range(1,m+1): sn = py_get_string("apply_name_index(%d)" % i) st = py_get_string("apply_type(%s)" % sn) so = py_get_string("apply_opt(%s,dof_values)" % sn) str = " Boundary Cond %14s Type %19s Values by: % s" % (sn,st,so) print str m = py_get_int("ngeoms()") print "\n Geometric Properties ",m for i in range(1,m+1): sn = py_get_string("geom_name_index(%d)" % i) st = py_get_string("geom_type(%s)" % sn) p = py_get_float("geom_par(%s,thick)" % sn) Geometric Prop %12s Type %19s Thick %g" % (sn,st,p) str = " print str m = py_get_int("niconds()") print "\n Initial Conditions ",m for i in range(1,m+1): sn = py_get_string("icond_name_index(%d)" % i) st = py_get_string("icond_type(%s)" % sn) so = py_get_string("icond_opt(%s,dof_values)" % sn) str = " Initial Cond %14s Type %12s Values by: %s" % (sn,st,so)

56 Marc Python Tutorial

74. 75. 76. 77. 78. 79. 80. 81. 82. 83. 84. 85. 86. 87. 88. 89. 90. 91. 92. 93. 94. 95. 96. 97. 98. 99. 100. 101. 102. 103. 104. 105. 106. 107.

print str print "" sn = py_get_string("material_name()") print " print " print " print " print " print "" sn = py_get_string("ctable_name()") print " Contact Table ", sn sn = "contact_table:the_mesh:refined_mesh:dist_tol" dt = py_get_data(sn) print " print "" sn = py_get_string("geom_name()") print " print " print "" m = py_get_int("nelements()") max_eid = py_get_int("max_element_id( )") print " Elements ", m, " for i in range(1,m+1): id = py_get_int("element_id(%d)" % i) print "" Maximum id ", max_eid Current geometry data: ", sn Thickness : ", thick thick = py_get_data("geometry:thick") Contact Dist Tol : ", dt Current material data: ", sn Type Youngs Modulus Poissons Ratio Yield Stress : ", st : ", e : ", p : ", ys st = py_get_string("material_type(%s)" % sn) e = py_get_data( "material:isotropic:youngs_modulus") p = py_get_data("material:isotropic:poissons_ratio") ys = py_get_data("material:plasticity:yield_stress")

CHAPTER 7 57 PyMentat: Obtaining Model Data

108. 109. 110. 111. 112. 113. 114. 115. 116. 117. 118. 119. 120. 121. 122. 123. 124.

sn = "element_class(%d)" % id e_class = py_get_int(sn) sn = "element_family(%d)" % id e_fam = py_get_int(sn) e_ty = py_get_int(sn) print " Element ", id, " Class ",e_cl," Family ",e_fam,", Type ",e_ty cbn = py_get_string("element_cbody(%d)" % id) gmn = py_get_string("element_geom(%d)" % id) orn = py_get_string("element_orient(%d)" % id) mtn = py_get_string("element_material(%d)"% id) print " print " print " print " return Contact Body Orientation : ", cbn : ", orn Geometry Property : ", gmn Material Property : ", mtn

125. if __name__ == '__main__': 126. 127. 128. Lines 3 Lines 5-6 Line 8 Line 9 Line 10 Line 11 Line 12 Line 14 Line 15 Line 16 Line 17 py_connect('',40007) main() py_disconnect() Open the model to examine the set information. Obtain and print the number of sets found. This uses the nsets Database function. Loop through all the sets in the model. The sets begin at 1. Obtain the set ID. All of the set database functions will use the Set Id to locate the set information. Obtain the set name using the set_name database function. Obtain the set type using the set_type database function. Obtain the number of entries in this set. Ignore the loadcase, boundary condition (apply) and initial condition (icond) set types. These are associated with the loadcase data. Print the set header information. Loop through all the entries in this set. Using the set_entry database function, obtain each item, and print out the results.

58 Marc Python Tutorial

Line 18-26 Line 28-34

Depending on the set type, obtain the edge number or the face number if it is an edge or face set. 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. 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. 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 Youngs 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 36-74

Line 76-99

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.

CHAPTER 7 59 PyMentat: Obtaining Model Data

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 icond_velo_nodes is a node set with 1 entries entry 1 is 5 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 icond_usersub_nodes is a node set with 1 entries entry 1 is 15 apply_usersub_nodes is a node set with 1 entries entry 1 is 16 Set output from chap7.py

Set Set

Set Set

Figure 7-1

The database output is shown in Figure 7-2.

60 Marc Python Tutorial

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 Type Youngs Modulus Poissons Ratio Yield Stress Contact Table Contact Dist Tol : : : : : : : steel mechanical/isotropic 30000000.0 0.3 32000000.0 ctable1 0.01

CHAPTER 7 61 PyMentat: Obtaining Model Data

Current geometry Thickness Contact Table Contact Dist Tol Elements Element 1 4

: :

th_shell 0.7

0.01 4 3 , Type 18

Maximum id Class 4 : : : :

Family

Contact Body Geometry Property Orientation Material Property Element 2 Class 4 Contact Body Geometry Property Orientation Material Property Element 3 Class 4 Contact Body Geometry Property Orientation Material Property Element 4 Class 4 Contact Body Geometry Property Orientation Material Property Loadcase ArcLength Method Job Follower Force Figure 7-2

the_mesh th_shell steel Family 3 , Type refined_mesh th_shell steel Family 3 , Type the_mesh membrane stainless Family 3 , Type refined_mesh membrane stainless : : : : forge_align , Type advanced_crisf static 3 3 18

: : : :

: : : :

: : : :

forging_analysis , Type begin_inc

mechanical

Database output from chap7.py

62 Marc Python Tutorial

Set IDs 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

PyPost: Reading a Post File

Chapter Overview PyPost Basics 64

64

Running the Script

66

64 Marc Python Tutorial

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. 4. 5. 6. 7. 8. 9. 10. 11. max_scalars = [] max_nodes = [] p = post_open(fname) try: p.moveto(1) except: print Error opening post file: ,fname return

CHAPTER 8 65 PyPost: Reading a Post File

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

66 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 methods called will be members of this PyPost object. 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. Go to the first increment. 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. 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. This statement will call the node_scalars method to obtain the total number of nodal scalars stored in the post file. The lists are initialized. This begins the main loop for the scalars. 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. 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. Get the scalar value for this scalar (k) and node (j). Ignore the sign of the values and only work with magnitudes. Check the current value against the current maximum value. Convert the node sequence number to the node id using the node_id method. Print out the results for each scalar.

Lines 4-5

Line 7 Lines 4-8

Lines 10-11 Line 13 Lines 15-17 Line 20 Line 22 Line 23

Line 24 Lines 25-26 Lines 27-29 Lines 35-37

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.

CHAPTER 8 67 PyPost: Reading a Post File

Found

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 Resulting Output from chap8.py

Figure 8-1

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

Chapter 9: PyPost: Obtaining Element Data

PyPost: Obtaining Element Data

Chapter Overview

69 69

Processing Element Data Running the Script 73

CHAPTER 9 69 PyPost: Obtaining Element Data

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 translate 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. 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. The average of all the integration points is computed and assigned to the nodes. Therefore, all nodes have an equal value assigned to them.

average

Consider the quadrilateral element shown Figure 9-1.

70 Marc Python Tutorial

4 3

7 4

1 1 5 2 1 5

Eight node quadrilateral Node Integration pt

Four Gaussian integration points

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. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. max_scalars = [] max_nodes = [] max_incs = [] nns = p.node_scalars() p = post_open(fname) try: p.moveto(1) except: print Error opening post file: ,fname return

CHAPTER 9 71 PyPost: Obtaining Element Data

14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27.

nes = p.element_scalars() ninc = p.increments() print " Increments = ",ninc,", Element scalars ",nes for i in range(0,nns+nes): max_scalars.append(-1.0) max_nodes.append(0) max_incs.append(0) for i in range(1, ninc): p.moveto(i) print "scanning increment ",i," post file number ",p.increment Nodal scalars = ",nns, ",

28. # find maximum nodal scalars 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. # find maximum element scalars 45. 46. j = 0 while j < nes: j = 0 while j < nns: k = 0 numnodes = p.nodes() while k < numnodes: d = p.node_scalar(k,j) if d < 0.0: d = -d if d > max_scalars[j] : max_scalars[j] = d max_nodes[j] = p.node_id(k) max_incs[j] = p.increment k = k + 1 j = j + 1

72 Marc Python Tutorial

47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. 69. 70. 71. 72. 73. 74. 75. 76. 77.

k = 0 numelems = p.elements() while k < numelems: sca = p.element_scalar(k,j) l = len(sca) m = 0 while m < l : val = sca[m] if val < 0.0: val = -val if val > max_scalars[nns+j] : max_scalars[nns+j] = val max_nodes[nns+j] = nod[m] max_incs[nns+j] = p.increment m = m + 1 k = k + 1 j = j + 1 print " Item Label increment node scalar"

print " ------------------------------------------" for i in range(0,nns+nes): if i < nns: s = p.node_scalar_label(i) else: s = p.element_scalar_label(i-nns) str = "%7i %36s %7i %10i %g" % ((i+1),s,max_incs[i], max_nodes[i],max_scalars[i]) print str return

78. if __name__ == '__main__': 79. main("../c06/chap5_job1.t16")

CHAPTER 9 73 PyPost: Obtaining Element Data

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. 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. 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. 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. The lists are initialized. Note that the lists contain both the nodal and element scalar data. The outer loop is the one for the increments. 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. This is the nodal scalars section, which is the same as that of the previous chapter. Begin the loop for the element scalars. 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. 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. Loop over every node in the list. The PyScalar list returned is "read-only". This means that the values in the list cannot be changed. Check each value in the PyScalar list and compare them to the maximum values. Print out the results for each scalar.

Lines 4-8

Lines 10-12

Lines 13-14

Lines 19-22 Line 24 Lines 25-26

Lines 29-42 Lines 45 Lines 48-49 Line 50

Line 53 Line 54 Lines 55-60 Lines 65-74

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

74 Marc Python Tutorial

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 52 106931 11 Equivalent Von Mises Stress Layer 3 240 83 77594.8 12 Equivalent Von Mises Stress Layer 5 240 25 103107 13 Equivalent Plastic Strain Layer 1 240 53 0.181767 14 Equivalent Plastic Strain Layer 3 240 84 0.0871299 15 Equivalent Plastic Strain Layer 5 240 25 0.211298

Figure 9-2

Resulting Output from chap8.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

76 76

Processing Element Tensor Data Running the Script 79

76 Marc Python Tutorial

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. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. def node(self): return self.Node def value(self): return self.Value def increment(self): return self.Inc def set_data(self, v,n,i): self.Value = v self.Node = n self.Inc = i def __init__(self, v, n, i): self.Value = v self.Node = n self.Inc = i

CHAPTER 10 77 PyPost: Element Tensor Data

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

78 Marc Python Tutorial

56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. 69. 70. 71. 72. 73. 74. print " Item

l = len(el) m = 0 while m < l : d = el[m].intensity if d > max_values[j].value() : max_values[j].set_data(d, el[m].id, i) m = m + 1 k = k + 1 j = j + 1 i = i + 1 # next increment Label increment node tensor"

print " ------------------------------------------" for i in range(0,net): j = max_value[i].node() s = p.element_tensor_label(i) str = "%7i %16s %7i %10i %g" % ((i+1),s,max_values[i].increment(), j,max_values[i].value()) print str return 1

75. 76. 77.

78. def main(fname): 79. 80. 81. 82. if __name__ == '__main__': 83. Line 2 Lines 3-21 Line 24 main(sys.argv[1]) The system module sys is imported to provide access to the command line arguments. A Python class is created to hold and retrieve the data. The post_open routine is called with the post file name passed in as the first command line argument. get_tensors(fname) return

CHAPTER 10 79 PyPost: Element Tensor Data

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. The number of element tensors and the number of increments in the post file are obtained. Begin the increment loop. Obtain the number of elements in this increment. Rezoning may cause the number of elements to change between increments. Obtain the list of PyTensors, and find the length of the list. 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. Print the results. In line 69, the node method of the TensorData class is called to obtain the node ID. The filename is specified as the first argument to the script.

Lines 33-34 Line 46 Line 53 Lines 55-58 Lines 58-61 Lines 71-75 Line 83

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

11

PyMentat: Using the py_connect Method

Chapter Overview

81 81

Creating a Simple Python Script for Marc Mentat The py_connect Method Handling Socket Errors Running the Script 83 81 82

CHAPTER 11 81 PyMentat: Using the py_connect Method

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. 14. 15. py_connect("",40007) main() 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 Mentats 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 Mentats 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.

82 Marc Python Tutorial

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. 3. 4. 5. 6. 7. 8. if __name__ == __main__: port = 40007 if len(sys.argv) > 1: port = sys.argv[1] py_connect("",port) main() 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.

CHAPTER 11 83 PyMentat: Using the py_connect Method

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.

84 Marc Python Tutorial

You may also type the *define command in Mentats 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

86 86

Charting Script for Mentat The Gnuplot Module 89

The PyOpenGL Module

93

86 Marc Python Tutorial

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. 11. 12. 13. 14. 15. 16. 17. opt(set_color=(0xff8080, 0x8080ff, 0x80ff80)) opt(bg_color=0xaaaaaa, plot_color=0x0000cd, line_color=0x000000,format=gdchart.GDC_JPEG) opt(title=t, xtitle='Increment', ytitle=' Y-Displ',grid=1) f=open(fname,wb) gdchart.chart(gdchart.GDC_LINE, size, f, Incs, dta[0], dta[1], dta[2], dta[3]) f.close()

CHAPTER 12 87 PyPost: Plotting

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

88 Marc Python Tutorial

52. 53. 54. 55. 56. 57. 58. 59. 60. if __name__ == '__main__': 61. Line 2 Lines 9-17 Line 27 Lines 31-33 Line 35 Line 38-41 Line 43 Lines 49-51 Lines 53-56 main("../c09/chap9.t16") The chart module gdchart is imported. 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. Create the list of nodes IDs to plot. Create a two-dimensional array for the displacements. The list is the size [number of nodes to plot] x [number of increments]. Create a string array for the increments. Find the index to the displacements for the node scalars. Loop through all the increments. 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. Create the title for the plot. It will contain the list of the nodes used in the plot. do_plot("chapt12a.gif", title, Incs ,displacements) title = "Nodes " for k in range(0,len(check_nodes)-1): title = title + `check_nodes[k]` + "," title = title + `check_nodes[len(check_nodes)-1]`

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.

CHAPTER 12 89 PyPost: Plotting

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. 6. # Check if the package has been installed correctly import Gnuplot

90 Marc Python Tutorial

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

CHAPTER 12 91 PyPost: Plotting

40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. if __name__ == '__main__': 69. Lines 4-8 Line 10 main("chap12.t16") Use the try/except statement to trap an error if the module gnuplot is not available. The gnu_plot routine is a convenient wrapper function to the plotting routine Gnuplot in the gnuplot module. gnu_plot("chap12b.ps", "Node Displacements", Incs, displacements, check_nodes) # find all y displacements for specified nodes for k in range(len(check_nodes)): j = p.node_sequence(check_nodes[k]) dy = p.node_scalar(j,nlocy) displacements[k][i] = dy # k for i in range(1, ninc): p.moveto(i) print "scanning post file increment",p.increment Incs[i] = p.increment # find the index for the displacements for i in range(0,nns): s = p.node_scalar_label(i) if s == "Displacement Y" : nlocy = i Incs = [0] * ninc nlocy = 0 check_nodes = (42,66,78, 86) displacements = [None]*len(check_nodes) for i in range(0,len(check_nodes)): displacements[i] = [0.0] * ninc

92 Marc Python Tutorial

Line 12 Lines 14-15 Line 16 Line 18-19 Lines 20-21 Line 22 Line 23-26 Line 28 Line 30 Lines 33-66

Create the Gnuplot object. Set the title, the linestyle, and the size of the plot. Create an array to store the Gnuplot Data objects. 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. Set the x and y axis labels. 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. If the platform is Microsoft Windows, pause the display. Otherwise wait for five seconds and then exit. Create the postscript file. Sleep (or pause) the program. If this is not done, a file is not generated. 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

CHAPTER 12 93 PyPost: Plotting

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. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. def __init__(self, i, xv, yv, dxv, dyv): self.Id = i self.X self.Y = xv = yv

self.dX = dxv self.dY = dyv def x(self): return self.X def y(self): return self.Y def dx(self): return self.dX def dy(self): return self.dY def id(self): return self.Id

94 Marc Python Tutorial

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

self.Bottom = bottom self.Top = top self.Width = w self.Height = h def left(self): return self.Left def right(self): return self.Right def bottom(self): return self.Bottom def top(self): return self.Top def width(self): return self.Width def height(self): return self.Height

CHAPTER 12 95 PyPost: Plotting

62. BMfonts = 63. 64. 65.

( "glut9by15", "glut8by13",

"glutTimesRoman10", "glutTimesRoman24", "glutHelvetica10", "glutHelvetica12", "glutHelvetica18" )

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

93. # draw the deformed shape

96 Marc Python Tutorial

96. 97. 98. 99. 100. 101.

glVertex2f(nodedx[i], nodedy[i]) glVertex2f(nodedx[i+1], nodedy[i+1]) glVertex2f(nodedx[i+2], nodedy[i+2]) glEnd() return

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

CHAPTER 12 97 PyPost: Plotting

130. 131. 132. 133. 134.

glVertex2f(x2, y-.1) glEnd() draw_string("deformed",x2+.05, y-.1) return

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

98 Marc Python Tutorial

164. 165. 166. 167. 168. 169. 170. 171. 172. 173. 174. 175.

global maxx, maxy, minx, miny global nod global win global o, p p = post_open(fname) p.moveto(1) nns = p.node_scalars() ninc = p.increments() print " Increments = ",ninc # List of Displ objects

176. # find the index ih the scalar label list for the displacements 177. 178. 179. 180. 181. 182. 183. 184. # go to the last increment 185. 186. 187. 188. # get nodes 189. 190. 191. 192. 193. 194. 195. 196. 197. nod = [Displ] * p.nodes() while k < n: j = p.node_id(k) i = k np = p.node(k) dx = p.node_scalar(k,nlocx) dy = p.node_scalar(k,nlocy) nod[k] = Displ(j,np.x, np.y,dx,dy) k = k + 1 p.moveto(p.increments()-1) k = 0 for i in range(0,nns): s = p.node_scalar_label(i) if s == "Displacement X" : nlocx = i if s == "Displacement Y" : nlocy = i

CHAPTER 12 99 PyPost: Plotting

198. 199. 200. 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. 207. 208. 209. 210. 211. 212. 213. 215. 216. 217. 218. 219. 220. 221. 222. 223. 224. 225. 226. 227. 228. 229. # Generate the Win object containing the viewport info 230. 231. minx = minx - .25*(maxx-minx) maxx = maxx + .25*(maxx-minx) k = k +1 cnt=0 while k < p.elements(): el = p.element(k) for m in range(0,el.len): id=find_node(el.items[m],nod) if id >=0 : nodex[cnt] = nod[id].x() nodey[cnt] = nod[id].y() nodedx[cnt] = nod[id].x() + nod[id].dx() nodedy[cnt] = nod[id].y() + nod[id].dy() find_maxmin(nodex[cnt], nodey[cnt]) find_maxmin(nodedx[cnt], nodedy[cnt]) cnt = cnt+1 214. # build the x and y coordinate arrays nodex = [0.0]*(n*3) nodey = [0.0]*(n*3) nodedx = [0.0]*(n*3) nodedy = [0.0]*(n*3) maxx = maxy = -10000.0 minx = miny = 10000.0 k = 0 n = p.elements()

100 Marc Python Tutorial

232. 233. 234. 235. 236. 237. 238. 239. 240. 241. 242. 243. 244. 245. 246. 247. 248.

miny = miny - .25*(maxy-miny) maxy = maxy + .25*(maxy-miny) win = Win(minx, maxx,miny, maxy, width(), height()) f = Frame() f.pack(side='top',expand=1) quit=Button(f,text = 'Quit',command =sys.exit).grid(row = 0, column = 0, sticky =W) t = "Increments " + `p.increments()` lbl = Label(f, text=" ").grid(row=0, col=2, sticky=W) lbl = Label(f, text=t).grid(row=0, col=3, sticky=W) o = Opengl(width = width(), height = height(), double = 1) o.redraw = redraw o.pack(side = 'top', expand = 1, fill = 'both') o.focus_set() o.mainloop()

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

CHAPTER 12 101 PyPost: Plotting

Lines 116-133 Lines 135-147

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. 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. The find_node routine finds the index of a node id in the nod array. 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. Declare some global variables. Determine the index of the X and Y displacements in the post file. Create an array of Displ objects to store the displacement data. Loop over all of the nodes and create an object. Create the arrays to store the actual x and y coordinates to plot. Loop through all the elements. 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. Find the minimum and maximum values for the data so that the window can be created with the proper limits. Create the window frame using the Tkinter toolkit. Create a quit button and a label that specifies the number of increments. 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).

Lines 149-153 Lines 155-160 Lines 163-167 Lines 176-182 Lines 188-197 Lines 206-209 Line 215 Lines 217-226

Lines 229-234 Lines 236-237 Lines 238-242 Lines 243-247

102 Marc Python Tutorial

Figure 12-3

The Resulting Plot from chap12c.py

Chapter 13: PyMentat: Menu System Lookup Functions

13

PyMentat: Menu System Lookup Functions

Chapter Overview

104 104

Menu System Lookup Functions Integer Function Double Function String Function Boolean Function State Function 105 105 105 106 107

104 Marc Python Tutorial

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 Double String Boolean State py_ms_int py_ms_double py_ms_string py_ms_bool 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 tables 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.

CHAPTER 13 105 PyMentat: Menu System Lookup Functions

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

106 Marc Python Tutorial

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.

CHAPTER 13 107 PyMentat: Menu System Lookup Functions

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 acis_file_type acis_file_check adapg_option Description *set_acis_formatted command state: returns 0 if Acis file type is formatted, 1 if binary. *set_acis_entity_check command state: returns 0 if entity check is off, 1 if on.

108 Marc Python Tutorial

Table 13-1

State Functions Function Description

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

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

CHAPTER 13 109 PyMentat: Menu System Lookup Functions

Table 13-1

State Functions Function Description 0 = and, 1 = except, 2 = invert, 3 = intersect 0 = side a, 1 = side b, 2 = external, 3 = create new 0 = side a, 1 = side b 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 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 Solid type: 0 = block, 1 = cylinder, 2 = prism, 3 = sphere, 4 = torus 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 0 for elements, 1 for nodes. 0 for elements, 1 for contact bodies Flag for insert generation during rebar remeshing: 0 is off, 1 is on. Flag for *set_view_repeat command: 0 is off, 1 is on. 0 = curve, 1 = bar, 2 = scatter 0 = curve, 1 = bar, 2 = scatter 0 = curve, 1 = bar, 2 =s catter 0 = curve, 2 = scatter 0 = curve, 1 = bar, 2 =s catter State of DXF file import for model/paper space: 0 is model, 1 is paper, 2 is both.

select_mode servo_match_rtype servo_match_ttype set_curve_type

set_element_class

set_solid_type set_surface_type

set_insert_embedded_type set_insert_host_type set_insert_create set_view_repeat set_xy_draw_type_histplot set_xy_draw_type_pathplot set_xy_draw_type_table set_xy_draw_type_xcurve set_xy_draw_type_xy_plot set_import_space srfprop_option strline_option table_indep_vars table_xvar table_yvar tform_option weldpath_option

State of current tables number of independent variables. Returns : 0 is 1 indep var, 1 is 2 indep var, 2 is3 indep var, 3 is4 indep var, State of current table x axis variables (V1-V4): Returns: 0 is V1, 1 is V2, 2 is V3, 3 is V4. State of current table y axis variables (V1-V4): Returns: 0 is V1, 1 is V2, 2 is V3, 3 is V4.

110 Marc Python Tutorial

Table 13-1

State Functions Function Description State of *xcv_discontinuous command: 0 is off; 1 is on. State of *xcv_err_abs command: 0 is off; 1 is on. State of *xcv_hyp_tc command: 0 is tensile; 1 is compressive.

xcv_discontinuous xcv_err_abs xcv_hyp_tc

Chapter 14: MentatDCOM: Connecting to Mentat using a .NET Module

14

MentatDCOM: Connecting to Mentat using a .NET Module

Chapter Overview MentatDCOM Basics

112 112 115 116

Running the Program

MentatDCOM and PyMentat

112 Marc Python Tutorial

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();

CHAPTER 14 113 MentatDCOM: Connecting to Mentat using a .NET Module

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. 2. 4. { 5. class Chap14 6. { 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. } return; } y = y + dely; p.send(str); x = x + delx; static MentatData p; static void make_nodes(int s, int t, double xs, double ys) { int i, j; double x, y, z, delx, dely; y = ys; z = 0.0; delx = 1.0/(double)s; dely = 1.0/(double)t; string str; for(i = 0; i < t; i++) { x = xs; for(j = 0; j < s; j++) { str = "*add_nodes " + x.ToString() + " " + y.ToString() + " " + z.ToString(); using System; using MentatDCOM;

3. namespace MentatTest

114 Marc Python Tutorial

31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64.

} static void make_elements(int n, int m) { int i, j, n1, n2, n3, n4; string str; for(i = 1; i < m; i++) { n1 = (i-1) * (n) + 1; n2 = n1 + 1; n4 = n1 + (n); n3 = n2 + (n); for(j = 1; j < n; j++ ) { str = "*add_elements "+n1.ToString()+" " + n2.ToString() + " " + n3.ToString() + " " + n4.ToString(); p.send(str); n1++; n2++; n3++; n4++; } } return; } static void Main(string[] args) { string host = "local"; if (args.Length > 0){ host = args[0]; } Console.WriteLine("chap14 {0}", host); p = new MentatData(); // the "x" dir // the "y" dir

CHAPTER 14 115 MentatDCOM: Connecting to Mentat using a .NET Module

65. 66. 67. 68. 69. 70. 71. 72. 73. 74. 75. 76. 77. 78. 79. 80. } Lines 1-2 Lines 7 Lines 8-55 Lines 60-62 Line 64 Lines 65-69 Lines 70-75 Line 76

if (p.connect(host) > 0) { Console.WriteLine("Failed to connect to {0}", host); return; } int n = 6; int m = 8; double xs = -1.0; double ys = -1.0; make_nodes(n, m, xs, ys); make_elements(n, m); p.disconnect(); return; } // end Main } // end class

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. Declare the MentatData object member.he argument list passed to the main function is checked for the post file name. This code is similar to the Python code of Chapter 2. The argument list passed to the main function is checked for the host name. 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. The connect method is called with the hostname of the computer. This code is similar to the Python code of Chapter 2. 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

116 Marc Python Tutorial

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

CHAPTER 14 117 MentatDCOM: Connecting to Mentat using a .NET Module

disconnect()

This method is called py_disconnect in PyMentat and closes the DCOM connection. p.disconnect(); This method is called py_send in PyMentat and sends a command string: p.send(*set_grid on); This method is called py_get_string in PyMentat and returns a string: String ^nm = p.get_string(model_name()); Console::WriteLine({0}, nm);

send() get_string()

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

15

MarcPost: Reading a Post File using a .NET Module

Chapter Overview MarcPost Basics

119 119 122 123

Running the Program MarcPost and PyPost

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

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()

120 Marc Python Tutorial

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

3. namespace MarcTest

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

31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. } }

for(k=0;k<numnodes;k++) { d = p.node_scalar(k,j); if(d < 0.0) d = -d; if(d > max_scalars[j]) { max_scalars[j] = d; max_nodes[j] = p.node_id(k); } } Console.WriteLine(" for(j=0;j<nns;j++) { Console.WriteLine(" {0,20} {1,10:d} p.node_scalar_label(j), max_nodes[j], max_scalars[j]); {2,-24:g}", Label node scalar");

Console.WriteLine(" ---------------------------------------------");

49. } // end Main 50. } // end class 51. } Lines 1-2 Lines 9-12 Line 14 Lines 15-19 Line 20 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.

The argument list passed to the main function is checked for the post file name. 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 The open method is called with the post file name chap5_job1.t16. 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. 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. The max_scalars array is initialized.

Lines 23-25

Line 27

122 Marc Python Tutorial

Line 28 Line 22 Line 28 Line 33 Lines 25-26 Lines 35-39 Lines 44-48

This begins the main loop for the scalars. 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. Loop through all the nodes. Get the scalar value for this scalar (k) and node (j). Ignore the sign of the values and only work with magnitudes. Check the current value against the current maximum value. Convert the node sequence number to the node id using the node_id method. 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\win32\MarcPost.dll chap15.cs \ /out:chap15_cs.exe on 32-bit Windows and 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 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 6

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

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 cutback cycles increment separation split soltype subinc Energy creepenergy dampenergy elasticenergy energy kineticenergy plasticenergy thermalenergy strainenergy Variables buckle frequency machangle pressure time mass volume Work appliedwork contactwork foundwork The buckling factor (for a buckling analysis) 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 machine angle (SuperForm only) The process pressure The transient time The total mass The total volume Description (from block 5180n) The total work done by applied force or displacement The total work done by contact or external forces The total work done by foundations The total creep strain energy The total damping energy The total elastic strain energy The total energy The total kinetic energy The total plastic strain energy The total thermal energy The total strain energy The total number of cutbacks The number of recycles for this increment The current increment The total number of separation recycles The total number of increment splittings The dynamic response flag: 0=Normal, 1=Modal, 2=Buckle, 3=Harmonic, 4=Complex. The current sub-increment. Non-zero for dynamic analysis. Description (from block 5180n) Description

124 Marc Python Tutorial

frictionwork springwork work

The total work due to friction The total work done by springs The total work

The MarcPost module uses the following special types: Node id x, y, z Element type id nnode nodes Nodal Data The node ID The x, y, z coordinates of the node Element Data The element type The element ID The number of nodes of the element The list of nodes for the element

The MarcPost module offers the following methods. int post_open(String ^filename) int close() String ^title() int increments() int domains() void moveto(int i) position() Opens the specified post file and returns 0 on success and 1 otherwise. Closes a currently open post file. Returns 0. Returns the title of the post file. Returns the number of increments on the post file. Returns the number of domains. Moves to the i-th increment on the post file. 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() int node_id(int i) int node_sequence(int id) Node ^node(int i) int node_displacements() int node_displacement(int i, double *x, double *y, double* z) int node_scalars() Returns the number of nodes in the model for the current increment. The number of nodes may change for each increment due to remeshing. Returns the id of the i-th node. Returns the index number of a particular node id or -1 if the id does not exist. Returns the nodal data for the i-th node. Returns 1 if displacements are available on the post file and 0 otherwise. Returns the x-, y- and z-displacements of the i-th node. The return value if the method is 0 on success and 1 on failure. Returns the number of nodal scalar quantities available.

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

double node_scalar(int i, int j) String^ node_scalar_label(int i) int node_vectors() String^ node_vector_label(int i) int node_vector(int i, int j, double *x, double *y, double *z) int elements() int element_id(int i) element_sequence(int id) Element^ element(int i) int element_scalars() String^ element_scalar_label(int i) int element_vectors() int element_tensors() String^ element_tensor_label(int i) int extrapolation(String^ type)

Returns the value of the j-th nodal scalar quantity at the i-th node. Returns the name of the i-th nodal scalar quantity. Returns the number of nodal vectors available. Returns the name of the i-th nodal vector. Returns the x-, y-, and z-components of the j-th nodal vector at the i-th node. The return value of the method is 0. Returns the number of elements in the model for the current increment. The number of elements may change for each increment due to remeshing. Returns the id of the i-th element. Returns the index number of a particular element id or -1 if the id does not exist. Returns the element data for the i-th element. Returns the number of element scalars available. Returns the name of the i-th element scalar. Returns the number of element vectors available. Returns the number of element tensor available. Returns the name of the i-th element vector. 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

String^ elelment_vector_label(int i) Returns the name of the i-th element vector.

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() String^ global_value_label(int i) double global_value(int i) int cbodies() int cbody_id(int i) String^ cbody_name(int i) double cbody_angle(int i) double cbody_volume(int i) Returns the number of global quantities available. Returns the name of the i-th global quantity. Returns the value of the i-th global quantity. Returns the number of contact bodies. Returns the id of the i-th contact body. Returns the name of the i-th contact body. Returns the angle for the i-th contact body. Returns the volume of the i-th contact body.

126 Marc Python Tutorial

double cbody_rotation(int i) int cbody_displacement(int i, double* x, double *y, double *z) int cbody_force(int i, double* x, double *y, double *z) int cbody_moment(int i, double *x, double *y, double *z) int cbody_velocity(int i, double *x, double *y, double *z) int sets() String ^version()

Returns the rotation for the i-th contact body. Returns the x-, y-, and z-displacements of the i-th contact body. The return value of the method is 0 if the body exists and 1 otherwise. Returns the forces in x-, y-, and z-directions for the i-th contact body. The return value of the method is 0 if the body exists and 1 otherwise. Returns the moments about the x-, y-, and z-axes for the i-th contact body. The return value of the method is 0 if the body exists and 1 otherwise. Returns the velocities in x-, y-, and z-directions of the i-th contact body. The return value of the method is 0 if the body exists and 1 otherwise. Returns the number of sets on the post file. 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 Variable Types 3

CHAPTER 3 Introduction

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

PyMentat References

PyMentat py_connect

5 6 7

py_disconnect py_echo 8 9

py_get_data py_get_float py_get_int py_get_string py_prompt py_send

10 11 12 13

14

CHAPTER 1 5 PyMentat References

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 *

6 Marc Python Reference

py_connect

Establishes a socket connection with Mentat

Synopsis py_connect(String hostname, Integer nPort) Arguments hostname nPort Hostname of system to make connection with 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()

CHAPTER 1 7 PyMentat References

py_disconnect
Synopsis py_disconnect() Arguments None Description

Terminates a socket connection with Mentat

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()

8 Marc Python Reference

py_echo

Enables/disables commands to be printed in Mentats 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 Mentats 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

CHAPTER 1 9 PyMentat References

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 = b = c = d = e = f = f =

py_get_data(material:isotropic:young_modulue) py_get_data(job:singularity_thresh) py_get_data(geometry:cont_radius) py_get_data(icond:base_vec1_x) py_get_data(apply:apply_dof_value_x) py_get_data(contact_body:friction) py_get_data(contact_table:ctable1:ctable2:friction)

10 Marc Python Reference

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 = str d = f = str f =

py_get_float(point_u1(npoints())) = curve_length(0)/curve_ndiv(0) py_get_float(str) py_get_float(node_x(0)*d) # is invalid = node_x(0)*%g % d py_get_float(str) # is correct

CHAPTER 1 11 PyMentat References

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 i = j = str j =

= npoints() py_get_int(npoints()) py_get_int(node_id(i)) = node_id(%d) % i py_get_int(str)

# is invalid # is correct

12 Marc Python Reference

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

CHAPTER 1 13 PyMentat References

py_prompt
Synopsis py_prompt(String name) Arguments name The string to print in the dialogue area.

Prints a string in the Mentat dialogue area

Description This routine prints the string name in the Mentat dialogue area. Example py_prompt(Evaluating Mesh)

14 Marc Python Reference

py_send

Sends commands to Mentat for execution

Synopsis py_send(String command) Arguments command 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) A string that contains the Mentat command(s) to be executed.

Chapter 2: PyPost References

PyPost References

PyPost close cbody

21 25 26 28 29

cbody_angle

cbody_displacement cbody_force cbody_moment cbody_name cbody_rotation cbody_transform cbody_velocity cbody_volume cbodies domain element elements element_id 37 38 39 40 41 42 43 32 33 34 35 36 30 31

element_scalar element_scalars

element_scalar_label element_sequence

44 45

20 Marc Python Reference

element_tensor element_tensors

46 47 48

element_tensor_label element_vector element_vectors 49 50

element_vector_label extrapolation global_value global_values 52 53 54 55

51

global_value_label increments moveto node nodes 57 58 59 56

node_displacement node_displacements node_id 62 63 64

60 61

node_scalar node_scalars

node_scalar_label node_sequence node_vector node_vectors 67 68

65 66

node_vector_label post_open set sets title 71 72 73 74 70

69

version

CHAPTER 2 21 PyPost References

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

22 Marc Python Reference

Variables buckle frequency The buckling factor (for a buckling analysis) 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 pressure time mass volume Work appliedwork contactwork foundwork frictionwork springwork work The machine angle (SuperForm only) The process pressure The transient time The total mass The total volume Description (from block 5180n) The total work done by applied force or displacement The total work done by contact or external forces The total work done by foundations The total work due to friction The total work done by springs The total work

The PyPost module uses the following special types: PyNode id x, y, z PyElement type len items PySet name type len items The node ID The x, y, z coordinates of the node Element Data The element type The number of nodes in the element The list of node IDs for the element Set Data The string representing the set name The set type, either node or element The number of items in the items list The list of nodes or elements Nodal Data

CHAPTER 2 23 PyPost References

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

24 Marc Python Reference

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

bodytype

4 - 3-D surfaces The physical type of the contact body: 1 - rigid 2 - deformable structural 3 - symmetry 4 - deformable heat-rigid 5 - workpiece (AutoForge)

center_x center_y center_z axis_x axis_y axis_z npoints points nelements elements npatches patches ncurves

6 - deformable acoustic The center of the contact body

The axis of the contact body

curves nsurfaces

surfaces

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. Array of PyNodes that describe the contact body 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. List of element IDs that describe the contact body. 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. List of PyPatchs that describe the contact body. 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. List of PyCurves that describe the contact body. 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. List of PySurfaces that describe the contact body.

CHAPTER 2 25 PyPost References

close
Synopsis close( ) Arguments None Description

Closes a currently open post file and frees any allocated memory

This method closes the post file associated with the PyPost object. Example p = post_open(c08_job1.t19) p.close( )

26 Marc Python Reference

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 name type

- contact body ID - name of the contact body (string) - 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 elements - number of element items - array of element IDs that comprise the contact body.

CHAPTER 2 27 PyPost References

If the contact body type is 1 the following are set: nlines lines - number of lines that comprise the contact body - array of lines (PyPatchs) 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 patches - number of patches that comprise the contact body - array of patches (PyPatchs) 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 points - number of point items - array of points (PyNodes) that comprise the contact body.

If the contact body type is 3 the following are set: ncurves curves - number of curve items - array of curves (PyCurves) that comprise the contact body.

If the contact body type is 4 the following are set: nsurfaces surfaces - number of surface items - array of surfaces (PySurfaces) that comprise the contact body.

Prior to post revision 8, only rigid contact bodies have the following set: center_x, center_y, center_z axis_x, axis_y, axis_z 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 - center of the contact body - axis of the contact body

28 Marc Python Reference

cbody_angle
Synopsis Float cbody_angle(Integer index) Arguments index cbody index number

Returns the angle for a particular contact body

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)

CHAPTER 2 29 PyPost References

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)

30 Marc Python Reference

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)

CHAPTER 2 31 PyPost References

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)

32 Marc Python Reference

cbody_name
Synopsis String cbody_name(Integer index) Arguments index Contact body index number

Returns the name of a particular contact body

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)

CHAPTER 2 33 PyPost References

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)

34 Marc Python Reference

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:
t0 t4 t8 t 12 t1 t5 t9 t 13 t2 t6 t 10 t 14 t3 t7 t 11 t 15

T =

Also See
cbodies, cbody_name

Example p = post_open(ch03_job1.t16) p.moveto(1) print cbody_transform(p.cbodies()-1)

CHAPTER 2 35 PyPost References

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)

36 Marc Python Reference

cbody_volume
Synopsis Float cbody_volume(Integer index) Arguments index Contact body index number

Returns the volume of a particular contact body

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)

CHAPTER 2 37 PyPost References

cbodies
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()

Returns the number of contact bodies

38 Marc Python Reference

domain
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()

Returns the number of domains in the post file

CHAPTER 2 39 PyPost References

element
Synopsis PyElement element(int nelem) Arguments nelem The element index number Description

Returns the element data for a particular element

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 len

- element type - 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

40 Marc Python Reference

elements
Synopsis Integer elements() Arguments None Description

Returns the number of elements in the current increment

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()

CHAPTER 2 41 PyPost References

element_id
Synopsis Integer element_id(Integer nelem) Arguments nelem The element index number Description Returns ID of element at index number nelem.

Returns ID of a particular element

Example p = post_open(c08_job1.t19) # print the ids of each element p.moveto(0) n = p.elements() for i in range(0,n): print Element ,i, has id , p.element_id(i)

42 Marc Python Reference

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 ns Element index number 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

CHAPTER 2 43 PyPost References

element_scalars
Synopsis Integer element_scalars() Arguments None Description

Returns the number of element scalars available

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)

44 Marc Python Reference

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)

CHAPTER 2 45 PyPost References

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 ids of each element p.moveto(0) n = p.elements() for i in range(0,n): print Element Id ,i, index ,p.element_sequence(i)

46 Marc Python Reference

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 ntens Element index number 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]

CHAPTER 2 47 PyPost References

element_tensors
Synopsis Integer element_tensors() Arguments None Description

Returns the number of element tensors available

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)

48 Marc Python Reference

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)

CHAPTER 2 49 PyPost References

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]

50 Marc Python Reference

element_vectors
Synopsis Integer element_vectors() Arguments None Description

Returns the number of element vectors available

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)

CHAPTER 2 51 PyPost References

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)

52 Marc Python Reference

extrapolation
Synopsis extrapolation(String type) Arguments type A string representing the integration method to use Description

Sets the integration point extrapolation method

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 translate 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. 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. The average of all the integration points is computed and assigned to the nodes. Therefore, all nodes have an equal value assigned to them.

average

Example P = post_open(c08_job1.t19) p.extrapolation(linear) print Extrapolation method is , p.extrapolate

CHAPTER 2 53 PyPost References

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.

Returns the value of a particular global value

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

54 Marc Python Reference

global_values
Synopsis Integer global_values() Arguments None Description

Returns the number of global values available

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)

CHAPTER 2 55 PyPost References

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)

56 Marc Python Reference

increments
Synopsis Integer increments() Arguments None Description

Returns the number of increments

The number of increments in the post file is returned. Note that increment 0 contains the model data. All scalar values are zero. Increment number 1 is the first increment in the post file that contains scalar data. For example, even if a post file only contains one increment, the increments method returns two. Example p = post_open(c08_job1.t19) n = p.increments()

CHAPTER 2 57 PyPost References

moveto
Synopsis moveto(Integer i) Arguments i increment number Description

Moves to the specified increment in the post file

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 frequency time of this increment 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

58 Marc Python Reference

node
Synopsis PyNode node(int nnode) Arguments nnode The node index number Description

Returns the nodal data for a particular node

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 y z - x coordinate - y coordinate - 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

CHAPTER 2 59 PyPost References

nodes
Synopsis Integer nodes() Arguments None Description

Returns the number of nodes in the current increment

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()

60 Marc Python Reference

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)

CHAPTER 2 61 PyPost References

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"

62 Marc Python Reference

node_id
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 ids of each node p.moveto(0) n = p.nodes() for i in range(0,n): print Node ,i, has id , p.node_id(i)

Returns the ID of a particular node

CHAPTER 2 63 PyPost References

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]

64 Marc Python Reference

node_scalars
Synopsis Integer node_scalars() Arguments None Description Returns the number of node scalars available.

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)

CHAPTER 2 65 PyPost References

node_scalar_label
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)

Returns the name of a particular scalar

66 Marc Python Reference

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)

CHAPTER 2 67 PyPost References

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

68 Marc Python Reference

node_vectors
Synopsis Integer node_vectors() Arguments None Description Returns the number of node vectors available.

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)

CHAPTER 2 69 PyPost References

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)

70 Marc Python Reference

post_open
Synopsis PyPost post_open(String filename) Arguments filename Post file name.

Open a post file and return the PyPost object

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 filename revision - current increment position - the post file name - the revision of the post file

The following members are updated when the moveto method is called: increment time frequency - the increment number of post file - the time for the current increment - 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

CHAPTER 2 71 PyPost References

set
Synopsis PyPostSet set(int nset) Arguments nset The set index number Description

Returns the data for a particular set

Returns a PyPostSet object containing the set data for set nset in the models. Members name type len - set name - set type - 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]

72 Marc Python Reference

sets
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()

Returns the number of sets in the post file

CHAPTER 2 73 PyPost References

title
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()

Returns the title of the post file

74 Marc Python Reference

version
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)

Returns the version of the PyPost module

Appendix A

Arithmetic and Database Functions

Introduction

80 80 81

Arithmetic Functions Database Functions Utility Functions 98

Post File Database Functions Set Functions 101

99

80 Marc Python Reference

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 Users 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
cos(arg1) sin(arg1) tan(arg1) dcos(arg1) dsin(arg1) dtan(arg1) acos(arg1) asin(arg1) atan(arg1) atan2(arg1,arg2) dacos(arg1) dasin(arg1) datan(arg1) datan2(arg1,arg2) log(arg1) ln(arg1) exp(arg1) cosh(arg1) sinh(arg1) tanh(arg1) acosh(arg1) asinh(arg1)

Description Cosine of arg1 radians Sine of arg1 radians Tangent of arg1 radians Cosine of arg1 degrees Sine of arg1 degrees Tangent of arg1 degrees Arccosine of arg1 radians Arcsine of arg1 radians Arctangent of arg1 radians Arctangent of (arg1/arg2) radians Arccosine of arg1 degrees Arcsine of arg1 degrees Arctangent of arg1 degrees Arctangent of (arg1/arg2) degrees Base-10 logarithm of arg1 Natural logarithm of arg1 E to the power arg1 Hyperbolic cosine of arg1 Hyperbolic sine of arg1 Hyperbolic tangent of arg1 Inverse hyperbolic cosine of arg1 Inverse hyperbolic sin of arg1

CHAPTER A 81 Arithmetic and Database Functions

Table A-1

Arithmetic Functions (continued) Function Description Inverse hyperbolic tangent of arg1 Square root of arg1 Angle in radians of arg1 degrees Angle in degrees of arg1 radians Absolute value of arg1 Largest integral value not greater than arg1 Fractional part of arg1 Maximum of arg1 and arg2 Minimum of arg1 and arg2 Distance in 2-D space between a point with coordinates (arg1,arg2) and a point with coordinates (arg3,arg4) a point with coordinates (arg4,arg5,arg6)

atanh(arg1) sqrt(arg1) rad(arg1) deg(arg1) abs(arg1) int(arg1) frac(arg1) max(arg1,arg2) min(arg1,arg2) dist2d(arg1,arg2,arg3,arg4)

dist3d(arg1,arg2,arg3,arg4,arg5,arg6) Distance in 3-D space between a point with coordinates (arg1,arg2,arg3) and

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
filename( ) getcwd( )

Database Functions Function Description Returns the name of the model file without the path. Returns the current directory.

82 Marc Python Reference

Table A-2
model_name( ) revision version

Database Functions (continued) Function Description Returns the current model name. Returns the string for the base version (such as 2011). Returns the string for the version (same as for *version command). Number of points in database ID of ARG1-th point in database Largest point ID in database ID of surface trimmed by point arg1 Global X-coordinate of point arg1 Global Y-coordinate of point arg1 Global Z-coordinate of point arg1 First user coordinate of point arg1 Second user coordinate of point arg1 Third user coordinate of pointarg1 First surface parametric coordinate of point arg1 Second surface parametric coordinate of point arg1 Number of curves in database ID of ARG1-th curve in database Largest curve ID in database Number of points of curve arg1 ID of ARG2 -th point of curve arg1 ID of surface trimmed by curve arg1 Length of curve arg1 Number of divisions of curve arg1 Number of seed points of a curve. It is identical to curve_ndiv(arg1)+1. 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). Number of surfaces in database ID of ARG1-th surface in database Largest surface ID in database Number of trimming curves of surface arg1 ID of ARG2-th curve in database that trims surface arg1

points( )
point_id(ARG1) max_point_id( ) point_surface_id(arg1) point_x(arg1) point_y(arg1) point_z(arg1) point_u1(arg1) point_u2(arg1) point_u3(arg1) point_s1(arg1) point_s2(arg1) ncurves( ) curve_id(ARG1) max_curve_id( ) ncurve_points(arg1) curve_point_id(arg1,ARG2) curve_surface_id(arg1) curve_length(arg1) curve_ndiv(arg1) ncurve_seedpoints(arg1) curve_seedpoint(arg1,ARG2)

nsurfaces( ) surface_id(ARG1) max_surface_id( ) nsurface_curves(arg1) surface_curve_id(arg1,ARG2)

CHAPTER A 83 Arithmetic and Database Functions

Table A-2

Database Functions (continued) Function Description Number of defining points in first parametric direction of surface arg1 Number of defining points in second parametric direction of surface arg1 ID of (ARG2, ARG3) -the defining point of surface arg1 Number of solids in database ID of ARG1-th solid in database Number of lumps of solid arg1 Number of faces of solid arg1 Number of edges of solid arg1 Number of vertices of solidarg1 Surface area of solid arg1 Volume of solid arg1 Number of nodes in database ID of ARG1-th node in database Largest node ID in database Global X-coordinate of node arg1 Global Y-coordinate of node arg1 Global Z-coordinate of node arg1 First user coordinate of node arg1 Second user coordinate of node arg1 Third user coordinate of node arg1 Transform name of node arg1. Number of elements in database ID of ARG1-th element in database Largest element id in database ID of ARG2-th node of element arg1 Name of the job Title of the job Class of element arg1. Returns an integer: LINE2 = 0 LINE3 = 1 TRIA3 = 2

nsurface_points_x(arg1) nsurface_points_y(arg1) surface_point_id(arg1,ARG2,ARG3) nsolids( ) solid_id(ARG1) nsolid_lumps(arg1) nsolid_faces(arg1) nsolid_edges(arg1) nsolid_vertices(arg1) solid_area(arg1) solid_volume(arg1) nnodes( ) node_id(ARG1) max_node_id( ) node_x(arg1) node_y(arg1) node_z(arg1) node_u1(arg1) node_u2(arg1) node_u3(arg1) node_tform(arg1) nelements( ) element_id(ARG1) max_element_id( ) element_node_id(arg1,ARG2) job_name( ) job_title( ) element_class(arg1)

84 Marc Python Reference

Table A-2

Database Functions (continued) Function 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 Description

element_dimension(arg1) element_family(arg1)

Dimension of element arg1 (returns either 2 or 3) Family of element arg1. Returns an integer: LINE = 1 TRIA = 2 QUAD = 3 HEX = 4 TETRA = 5 PENTA = 6

element_edges(arg1) element_edge_area(arg1,ARG2)

Number of edges for element arg1 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.

element_faces(arg1)

Number of faces for element arg1

CHAPTER A 85 Arithmetic and Database Functions

Table A-2

Database Functions (continued) Function Description 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_area(arg1,ARG2)

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. Number of nodes for element 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 associated with element ID arg1. For example, obtain type of last element: element_type(element_id(-1))

element_nodes(arg1) element_volume(arg1)

element_type(arg1)

element_cbody(arg1) element_geom(arg1) element_mater(arg1) element_orient(arg1) nadapgs( ) adapg_par(arg1,arg2)

Contact body name associated with element ID arg1 Geometric property name associated with element ID arg1 Material name associated with element ID arg1 Orientation property name associated with element ID arg1 Number of global remeshing criterion in the database 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.

86 Marc Python Reference

Table A-2

Database Functions (continued) Function Description 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_opt(arg1,arg2)

adapg_type(arg1) napplys( ) apply_name_index(ARG1) apply_opt(arg1,arg2)

Global remeshing criterion type for global remeshing criterion arg1. If arg1 is empty, then it uses the current global remeshing criterion. Number of boundary conditions in the database Boundary condition name of ARG1-th boundary condition criterion in database. 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) apply_par(arg1,arg2)

Boundary condition type for boundary condition named arg1. If arg1 is empty, then it uses the current boundary condition. 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 87 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( ) ncbodys( ) cbody_name_index(ARG1) cbody_opt(arg1,arg2)

Returns the name of the current boundary condition. Number of contact bodies in the database. Contact body name of ARG1-th global contact body in database. 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)

88 Marc Python Reference

Table A-2

Database Functions (continued) Function Description 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_par_table(arg1,arg2)

cbody_type(arg1) cbody_par(arg1,arg2)

Contact body type for contact body named arg1. If arg1 is empty, then it uses the current contact body. 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

ctable_name( ) nctables( ) ctable_name_index(ARG1) ctable_body_name_index(ARG1) ctable_entry_exist(arg1,arg2,arg3)

Returns the name of the current contact table. Number of contact tables in the database Contact table name of ARG1-th contact table in database. The name of the contact body that appears on row ARG1 of a contact table. 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 89 Arithmetic and Database Functions

Table A-2

Database Functions (continued) Function Description 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_opt(arg1,arg2,arg3,arg4)

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( ) icond_name_index(ARG1) icond_opt(arg1,arg2)

Number of initial conditions in the database Initial condition name of ARG1-th initial condition in database. 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.

90 Marc Python Reference

Table A-2

Database Functions (continued) Function Description 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_dof_val(arg1,arg2)

icond_name( ) icond_par(arg1,arg2)

Returns the name of the current initial condition. 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( ) geom_name( ) geom_name_index(ARG1) geom_opt(arg1,arg2)

Number of geometric properties in the database Returns the name of the current geometric property Geometic property name of ARG1-th geometry in database. 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 91 Arithmetic and Database Functions

Table A-2

Database Functions (continued) Function Description 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,

job_par(arg1,arg2)

92 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( ) job_class(arg1) job_name_index(ARG1) job_opt(arg1,arg2)

Number of jobs in the database. Job class for job named arg1. If arg1 is empty, then it uses the current job. job name of ARG1-th job in database. 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( ) lcase_opt(arg1,arg2)

Number of loadcases in the database 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) lcase_type(arg1) lcase_name( ) lcase_par(arg1,arg2)

Loadcase name of ARG1-th loadcase in database. Loadcase type for loadcase named arg1. If arg1 is empty, then it uses the current loadcase. Returns the name of the current loadcase. 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 93 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( ) nmaters( ) mater_id(arg1)

Returns the title of the current loadcase. Number of materials in the database. Returns the ID of the material named arg1 or of the current material if arg1 is empty

94 Marc Python Reference

Table A-2
mater_name( )

Database Functions (continued) Function Description Returns the name of the current material in the database Material name of ARG1-th material in database. 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_name_index(ARG1) mater_opt(arg1,arg2)

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) mater_nsubmats(arg1)

Material type for material named arg1. If arg1 is empty, then it uses the current material. 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. 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. 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)

mater_vsubmat_name(arg1,arg2)

mater_vsubmat_opt(arg1,arg2,arg3)

CHAPTER A 95 Arithmetic and Database Functions

Table A-2

Database Functions (continued) Function Description 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(arg1,arg2,arg3)

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

96 Marc Python Reference

Table A-2
pm_par(arg1)

Database Functions (continued) Function Example: pm_par(arg1) Example: *define aa MyText pm_par(aa) Description Returns parameter string named arg1.

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( ) nservos( ) nsprings( ) nties( ) link_class(arg1) tie_type(arg1) link_name_index(ARG1) link_name( ) tie_name () servo_name( ) spring_name( ) spring_par(arg1)

Number of links of any class in the database Number of links of class servo in the database Number of links of class spring in the database Number of links of class tie in the database Link type name for link arg1. One of: servo, spring, tie. If arg1 is empty, then it uses the current link. Tie type name for tie arg1. If arg1 is empty, then it uses the current tie. Link name of ARG1-th link in database. Returns the name of the current link. Returns the name of the current tie. Returns the name of the current servo. Returns the name of the current spring. 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 97 Arithmetic and Database Functions

Table A-2

Database Functions (continued) Function Description 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_par_table(arg1,arg2)

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( ) orient_name( ) orient_name_index(ARG1) orient_type(arg1) orient_opt(arg1,arg2)

Number of orientations in the database Returns the name of the current orientation. Orientation name of ARG1-th orientation in database. Orientation type for orientation arg1. If arg1 is empty, then it uses the current orientation. 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( ) tform_name( ) tform_name_index(ARG1) tform_opt(arg1,arg2)

Number of transforms in the database Returns the name of the current transform. Transform name of ARG1-th transform in database. 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.

98 Marc Python Reference

Table A-2
wz_par(arg1)

Database Functions (continued) Function 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 Description SuperForm Wizard parameter value named arg1.

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-1 Utility Functions Description 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) element_aspect_ratio(arg1)

Function
range(arg1,arg2,arg3)

Same as range except that arg3 (the increment value) is set as 1. Aspect ratio of element arg1 as computed by the *check_aspect command

CHAPTER A 99 Arithmetic and Database Functions

Table A-1

Utility Functions (continued) Description Distortion factor of element arg1 as computed by the *check_distorted command Returns 1 if element arg1 is inside out; 0 otherwise Returns 1 if element arg1 is upside down; 0 otherwise Returns the ID of the curve to which the ARG2-th edge of element arg1 is attached, 0 otherwise attached; 0 otherwise

Function
element_distortion(arg1) element_inside_out(arg1) element_upside_down(arg1) element_attach_curve(arg1, ARG2)

element_attach_surface(arg1, ARG2) Returns the ID of the surface to which the ARG2-th face of element arg1 is node_point_id(arg1) curve_x(arg1, u) curve_y(arg1, u) curve_z(arg1, u) surface_x(arg1, u, v) surface_x(arg1, u, v) surface_x(arg1, u, v) global_x(ux, uy, uz) global_y(ux, uy, uz) global_z(ux, uy, uz) user_def(arg1) user_x(gx, gy, gz) user_x(gx, gy, gz) user_x(gx, gy, gz)

Returns the ID of the point to which the node arg1 is attached, 0 otherwise X coordinate of a point on curve arg1 with natural coordinate u Y coordinate of a point on curve arg1 with natural coordinate u Z coordinate of a point on curve arg1 with natural coordinate u X coordinate of a point on surface arg1 with natural coordinates <u>,<v> Y coordinate of a point on surface arg1 with natural coordinates <u>,<v> Z coordinate of a point on surface arg1 with natural coordinates <u>,<v> Transform the user coordinates (<ux>,<uy>,uz>) to the global coordinate system and return the X coordinate. Transform the user coordinates (<ux>,<uy>,uz>) to the global coordinate system and return the Y coordinate. Transform the user coordinates (<ux>,<uy>,uz>) to the global coordinate system and return the Z coordinate. Returns the user defined data at the specified index arg1 that was set with the user_defined_data command. Transform the global coordinates (<gx>,<gy>,gz>) to the current user coordinate system and return the X coordinate. Transform the global coordinates (<gx>,<gy>,gz>) to the current user coordinate system and return the Y coordinate. 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.

100 Marc Python Reference

Table A-3

Post File Database Functions Description Global X displacement of node arg1. Global Y displacement of node arg1. Global Z displacement of node arg1. 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)

Function
displace_x(arg1) displace_y(arg1) displace_z(arg1) post_data(name)

post_increments( ) post_node_extra(arg1) scalar_1(arg1) scalar_2(arg1) scalar_max_element( ) scalar_min_element( ) scalar_max_node( ) scalar_min_node( ) scalar_pos(x,y,z)

If a post file is opened, it returns the number of increments in the post file. Returns 1 if node arg1 is an extra (dummy) node; 0 if a valid node. First scalar component of node arg1 Second scalar component of node arg1 Returns the first element in which the scalar quantity is the maximum value. Returns the first element in which the scalar quantity is the minimum value. Returns the first node in which the scalar quantity is the maximum value. Returns the first node in which the scalar quantity is the minimum value. 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 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 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 value of node arg1. This can be a post file value or a value calculated from *geomdist_surfaces or other vector creation commands. 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. 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.

vector_x(arg1) vector_y(arg1) vector_z(arg1) add_disp(arg1, arg2)

add_displ_x(arg1, arg2)

CHAPTER A 101 Arithmetic and Database Functions

Table A-3

Post File Database Functions (continued) Description 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. 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. 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. 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. 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. 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. Sets the global X displacement of node arg1 to arg2. Sets the global Y displacement of node arg1 to arg2. Sets the global Z displacement of node arg1 to arg2.

Function
add_displ_y(arg1, arg2)

add_displ_z(arg1, arg2)

scale_disp(arg1, arg2)

scale_displ_x(arg1, arg2)

scale_displ_y(arg1, arg2)

scale_displ_z(arg1, arg2)

set_displace_x(arg1, arg2) set_displace_y(arg1, arg2) set_displace_x(arg1, 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-4 Set Functions Description Returns 1 if set arg1 is a curve set, 0 otherwise. Returns 1 if set arg1 is a edge set, 0 otherwise. Returns 1 if set arg1 is a element set, 0 otherwise. Returns 1 if set arg1 is a face set, 0 otherwise. Returns 1 if set arg1 is a node set, 0 otherwise.

Function
is_curve_set(arg1) is_edge_set(arg1) is_element_set(arg1) is_face_set(arg1) is_node_set(arg1)

102 Marc Python Reference

Table A-4

Set Functions (continued) Description Returns 1 if set arg1 is a point set, 0 otherwise. Returns 1 if set arg1 is a surface set, 0 otherwise. Number of sets in database Number of set entries for set arg1 The ID of the ARG2-th edge set entry in edge set arg1. The value of the ARG2-th set entry in set arg1. The ID of the ARG2-th face set entry in face set arg1. ID of ARG1-th set in database Name of set arg1. This is a string value, and can only be used in py_get_string. 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.

Function
is_point_set(arg1) is_surface_set(arg1) nsets( ) nset_entries(arg1) set_edge(arg1, ARG2) set_entry(arg1, ARG2) set_face(arg1, ARG2) set_id(ARG1) set_name(arg1) set_type(arg1)