MARC Tutorials

Marc Python 2010
Tutorial and Reference Manual
Corporate
MSC.Software Corporation 2 MacArthur Place Santa Ana, CA 92707 Telephone: (800) 345-2078 FAX: (714) 784-4056
Europe
MSC.Software GmbH Am Moosfeld 13 81829 Munich GERMANY Telephone: (49) (89) 43 19 87 0 Fax: (49) (89) 43 61 71 6
Asia Pacific
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 Fax: (81) (3)-6911-1201
Worldwide Web
www.mscsoftware.com
User Documentation: Copyright 2010 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*V2010*Z*Z*Z*DC-PYTH
Contents
C O N T E N T S
Marc Python Tutorial and Reference Manual
Marc Python Tutorial Chapter

Preface

Organization of this Manual . . . . . . . . . . . . . . . . . . . . . . . . i-xiv Contents of the Chapters . . . . . . . . . . . . . . . . . . . . . . . . . . . i-xiv PART I PyMentat Module . . . . . . . . . . . . . . . . . . . i-xiv PART II PyPost Module . . . . . . . . . . . . . . . . . . . . . . i-xv PART III Advanced Discussions . . . . . . . . . . . . . . . . i-xv Documentation Conventions . . . . . . . . . . . . . . . . . . . . . . . . i-xvi
Chapter 1
Introduction

The Basics of Using PyMentat . . . . . . . . . . . . . . . . . . . . . . . .1-2 The Basics of Using PyPost . . . . . . . . . . . . . . . . . . . . . . . . . .1-5
A Brief Look at Python Programming . . . . . . . . . . . . . . . . . .1-7 Python Data Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1-8 Basic Data Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1-8 Extended Data Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1-8
Chapter 2
PyMentat: A Simple Example

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-2 Creating a Simple Python Script for Marc Mentat . . . . . . . . .2-3 Python Programming Hints . . . . . . . . . . . . . . . . . . . . . . . . . .2-5 Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-6
iv
Chapter 3
PyMentat: Obtaining Data from Marc Mentat

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3-2 Creating a Simple Python Script for Marc Mentat . . . . . . . . .3-3 The py_get_int and py_get_float methods . . . . . . . . . . . . . . .3-5 Running the Scrip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3-5
Chapter 4
PyMentat: Building Complex Geometry

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .4-2 Background Information . . . . . . . . . . . . . . . . . . . . . . . . . . . . .4-3 Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .4-6
Chapter 5
PyMentat: Adding Model Properties

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .5-2 Plate Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .5-3 Node and Element Ids . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .5-8 Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .5-10 Submitting the Job . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .5-11
Chapter 6
PyMentat: Processing a Post File

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .6-2 Postprocessing Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .6-3 Scalar Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .6-7 Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .6-7
Chapter 7
PyMentat: Obtaining Model Data

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7-2 Database Properties Basics . . . . . . . . . . . . . . . . . . . . . . . . . . .7-3 Set Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7-4 A Sample Script to Extract Data . . . . . . . . . . . . . . . . . . . . . . .7-5 Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7-12
Contents
Set Ids and Set Names . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7-16
Chapter 8
PyPost: Reading a Post File

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .8-2 PyPost Basic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .8-3 Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .8-6
Chapter 9
PyPost: Obtaining Element Data

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9-2 Processing Element Data . . . . . . . . . . . . . . . . . . . . . . . . . . . .9-3 Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9-8
Chapter 10
PyPost: Element Tensor Data

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10-2 Processing Element Tensor Data . . . . . . . . . . . . . . . . . . . . .10-3 Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10-7
Chapter 11
PyMentat: Using the py_connect Method

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11-2 Creating a Simple Python Script for Marc Mentat . . . . . . . .11-3 The py_connect Method . . . . . . . . . . . . . . . . . . . . . . . . . . . .11-3 Handling Socket Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11-4 Running the Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11-6
Chapter 12
PyPost: Plotting

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .12-2 Charting Script for Marc Mentat . . . . . . . . . . . . . . . . . . . . .12-3 The Gnuplot Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .12-7 The PyOpenGL Module . . . . . . . . . . . . . . . . . . . . . . . . . . .12-11
vi
Chapter 13
PyMentat: Menu System Lookup Functions

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .13-2 Menu System Lookup Functions . . . . . . . . . . . . . . . . . . . . .13-3 Integer Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .13-4 Double Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .13-5 String Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .13-6 Boolean Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .13-7 State Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .13-8
Chapter 14
MentatDCOM: Connecting to Mentat using a .NET Module

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14-2 MentatDCOM Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14-3 Running the Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14-7 MentatDCOM and PyMentat . . . . . . . . . . . . . . . . . . . . . . . .14-8
Chapter 15
MarcPost: Reading a Post File using a .NET Module

Chapter Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15-2 MarcPost Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15-3 Running the Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15-7 MarcPost and PyPost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15-8
Marc Python Reference Introduction

Using the Python Modules . . . . . . . . . . . . . . . . . . . . . . . . . . i-iv
Variable Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . i-iv String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . i-v Float . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . i-v Integer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . i-v List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . i-v
Contents
vii
Chapter 1
PyMentat References

PyMentat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1-2 py_connect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1-3 py_disconnect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1-4 py_echo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1-5 py_get_data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1-6 py_get_float . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1-7 py_get_int . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1-8 py_get_string . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1-9 py_prompt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1-10 py_echo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1-11
Chapter 2
PyPost References

PyPost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-4 close . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-10 cbody . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-11 cbody_angle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-14 cbody_displacement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-15 cbody_force . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-16 cbody_moment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-17 cbody_name . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-18 cbody_rotation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-19 cbody_transform . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-20 cbody_velocity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-21 cbody_volume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-22 cbodies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-23 domain . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-24
viii
element . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-25 elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-26 element_id . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-27 element_scalar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-28 element_scalars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-29 element_scalar_label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-30 element_sequence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-31 element_tensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-32 element_tensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-33 element_tensor_label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-34 element_vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-35 element_vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-36 element_vector_label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-37 extrapolation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-38 global_value . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-39 global_values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-40 global_value_label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-41 increments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-42 moveto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-43 node . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-44 nodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-45 node_displacement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-46 node_displacements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-47 node_id . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-48 node_scalar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-49 node_scalars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-50
Contents
ix
node_scalar_label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-51 node_sequence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-52 node_vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-53 node_vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-54 node_vector_label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-55 post_open . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-56 set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-57 sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-58 title . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-59 version . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-60
Appendix A
Arithmetic and Database Functions . . . . . . . . . . . . . . . . . . . A-2 Arithmetic Functions . . . . . . . . . . . . . . . . . . . . . . . . . . A-2 Database Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . A-4 Utility Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A-19 Post File Database Functions . . . . . . . . . . . . . . . . . . . A-21 Set Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A-24
MSC.Marc Python Tutorial
Python Tutorial
Marc Python Tutorial
Preface
Preface
Organization of this Manual Contents of the Chapters Documentation Conventions
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 Marc Mentat.
xiv
Organization of this Manual

This manual is divided into three parts: Part I introduces the user to the PyMentat module. This module interacts with Marc Mentat (which will be referred to as Marc Mentat) to create, modify, and post process models. Part II introduces the user to the PyPost module. This module functions independently of Marc Mentat to post process 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

Chapter 1 Introduction, provides information on the basics using PyMentat and of Python programming. PyMentat Module PyMentat: A Simple Example, describes a basic PyMentat script. PyMentat: Obtaining Data from Marc Mentat, expands on the common features of PyMentat and describes how a Python script can get data from Marc Mentat. PyMentat: Building Complex Geometry, displays how you can build complex geometry that cannot be done with procedure files alone. PyMentat: Adding Model Properties, shows how to add boundary conditions, material properties, geometric properties and job parameters to allow you to perform a complete linear elastic analysis of a rectangular strip with a series of holes subjected to compression loading. PyMentat: Processing a Post File, shows how to process a Marc post file. PyMentat: Sets, shows how to write PyMentat scripts to work with SETS.
PART I Chapter 2 Chapter 3
Chapter 4 Chapter 5
Chapter 6 Chapter 7
Preface
xv
PART II Chapter 8 Chapter 9 Chapter 10
PyPost Module PyPost: Reading a Post File, introduces the basics of using the PyPost module to obtain post file data and find the maximum scalar values. PyPost: Obtaining Element Data, shows how to obtain element scalar data from a post file. PyPost: Element Tensor Data, expands on obtaining element data by showing how to obtain element tensor data from a post file. It also introduces the PyTensor class. Advanced Discussions PyMentat: Using the py_connect Method, introduces the basics of using the PyMentat module in a client/server environment. PyPost: Plotting Post File Data, shows some example of using third party modules to plot the results of a post file.
PART III Chapter 11 Chapter 12
xvi
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 Marc Mentat screen are in UPPER CASE. The command issued will appear in lower case, such as *add_nodes. Note that the "*" always precedes the command name to instruct Marc 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 filename is in your current directory. You will note the patnames are specified with the forward slash character "/", as in examples/ python/userguide. For those using Microsoft Windows, you will need to substitute the forward slashes with the backslash character "\".
Chapter 1: Introduction
CHAPTER
Introduction
The Basics of Using PyMentat The Basics of Using PyPost A Brief Look at Python Programming
Welcome to Python a set of APIs designed to be used by Python scripts to enhance the functionality of Marc Mentat.
1-2
The Basics of Using PyMentat

When you select a menu item in Marc 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 Marc 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 Marc Mentat. Therefore, if you want your Python script to add a node, your script should send the command *add_nodes to Marc Mentat. Unless you are a very experienced Marc Mentat user, you will most likely develop your PyMentat Python script using the technique outlined in Figure 1-1.
CHAPTER 1
Introduction
1-3
GENERATE TEST MODEL
RUN py_create.py USING MENTAT.PROC TO CREATE INITIAL PYTHON SCRIPT
mentat.proc is created when Marc 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 Marc 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 will need to edit the resulting Python script to add PARAMETERS and other variables for conditional processing.
1-4
#!/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
CHAPTER 1
Introduction
1-5
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 Marc 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.
Table 1-1 Function close dies domains element elements element_id element_scalar element_scalars element_scalar_label element_sequence element_tensor element_tensors element_tensor_label element_vector element_vectors element_vector_label extrapolation increments moveto 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. 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
1-6
Table 1-1
(Continued) Function Description 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.
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
CHAPTER 1
Introduction
1-7
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 Marc 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. 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.
1-8
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
A character string similar to the char data in C and character in FORTRAN. a string may be specified using either single or double quotes.
float
A floating point number similar to the double data type in C and the real*8 data type in FORTRAN.
integer
An integer or fixed point number similar to the long int data type in C and the integer*8 data type in FORTRAN.
Extended Data Types List
A Python list is essentially a linked list that can be accessed like an array using the square bracket operators "[ ]". The list can be composed of strings, floats or integers to name a few. 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
CHAPTER
Chapter Overview Creating a Simple Python Script for Marc Mentat Python Programming Hints Running the Script
2-2
Chapter Overview
In this section, it will be demonstrated how to create a basic Python script that sends commands to Marc 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 Marc Mentat Python Menu layout
CHAPTER 2
2-3
Creating a Simple Python Script for Marc 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 Marc 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 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 # Create the node grid def make_nodes(s,t, xs, ys): 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 return # Create the element grid def make_elements(n,m): for i in range(1,m): # the "y" dir 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)
2-4
27 28 29 30 31 32 33 34 35 36 37 38 39 40
n1 n2 n3 n4 return
= = = =
n1 n2 n3 n4
+ + + +
1 1 1 1
def main(): n = 6 m = 8 xs = -1.0 ys = -1.0 make_nodes(n,m,xs,ys) make_elements(n,m) return
Lines 2-15
The make_nodes routine will create 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 Marc 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 Marc Mentat, at which time it will run the command string just as if it was typed in the Marc Mentat dialogue area.
Lines 18-31 The make_elements routine will perform the element connectivity of the node grid using the Marc Mentat command *add_elements. The loop beginning in line 24 will build the elements moving across the node grid in the X-direction and up the grid in the Y-direction. Lines 33-40 The main routine will set the size of the grid and the starting position.
CHAPTER 2
2-5
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 "deindented". 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 Marc 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.
2-6
Running the Script

Start Marc Mentat, and from the main screen select the following menu buttons.
MAIN UTILS PYTHON
This will bring up the Python Menu screen as shown in Figure 2-1.
Figure 2-1
Python Menu Screen
CHAPTER 2
2-7
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 will appear.
Figure 2-2
The Python Browser Window
2-8
Note the button named RUN AS SEPARATE PROCESS. This will run the script in a separate window and communicate to Marc Mentat using a BSD socket connection. This item will be 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 Marc 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 will be created as shown in Figure 2-3.
Figure 2-3
Python Menu Screen with a Created Mesh
In the next chapter, we will modify the script to use Marc Mentat PARAMETERS to create a variably sized grid.
Chapter 3: PyMentat: Obtaining Data from Mentat
CHAPTER
Chapter Overview Creating a Simple Python Script for Marc Mentat The py_get_int and py_get_float methods Running the Script
3-2
Chapter Overview
In this chapter, it will be demonstrated how to use Marc 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
CHAPTER 3
3-3

To continue with the example discussed in Chapter 2, we will examine a script that creates a simple element grid and uses Marc Mentat parameters to control the size of the grid. This example is named chap3.py and can be found in the Marc Mentat directory examples/python/tutorial/c03. The script is as follows:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 from py_mentat import * # Create the node grid def make_nodes(s, t, xs, ys): 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 return # Create the element grid def make_elements(n,m): for i in range(1,m): # the "y" dir 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
3-4
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
n4 = n4 + 1 return def main(): 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) if __name__ == __main__: py_connect("",40007) main() py_disconnect()
Lines 2-31
The make_nodes and make_elements routines are the same as in the previous chapter.
Lines 33-39 The main routine will obtain the values for the size of the grid and the starting point from Marc Mentat using parameters. The py_get_int method will evaluate a formula and return an integer (fixed point) result similar to the *calculator command. The py_get_float method will evaluate a formula and return a floating point number. In this case these methods obtain the values for these parameters. Lines 41-44 If the script is invoked as a separate process, (such as python chap3.py), then the Python interpreter sets the Python variable __name__ to the string __main__. If this is the case, then the Python script should attempt to make a socket connection to Marc Mentat. The py_connect method will be discussed in more detail in a later chapter.
CHAPTER 3
3-5
The py_get_int and py_get_float methods

The py_get_int and py_get_float methods provide access to Marc Mentat PARAMETERS and Arithmetic or Database functions. Using Marc Mentat parameters is the method to pass variables from Marc 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 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 Marc 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.
3-6
You may also type the *define command in Marc 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
CHAPTER
Chapter Overview Background Information Running the Script
4-2
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 Marc 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
CHAPTER 4
4-3
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 height
d t=.75
d s d
d X
width
Figure 4-1
Plate with varying Number of Holes
4-4
This example is named chap4.py and can be found in the Marc Mentat directory examples/python/tutorial/c04. The following is the Python script:
1 2 3 4 5 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 31 32 from py_mentat import * def add_plate(xs,ys,width, height): 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 def build_plate(xstart,ystart,width, height, diameter, spacing): 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 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
CHAPTER 4
4-5
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
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 def main(): 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 if __name__ == __main__: py_connect("127.0.0.1",40007) main()
Lines 2-16
The add_plate routine will create the plate using 4 connected curves. It first generates the end points of the curve using the *add_points command and then creates the curves by connecting the points with the *add_curves commands. In line 15, the *fill_view command is issued to center and fill the plate properly on the screen.
Lines 18-38 The build_plate routine will calculate the number of holes that can be placed in the plate and create 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
4-6
vertical (height) placement, and the inner loop in lines 35-37 controls the horizontal (width) placement. Lines 40-48 The main routine will obtain the values for the size of the plate, the diameter of the holes, and the spacing between holes from Marc Mentat. The lower left corner of the plate is calculated in lines 45-46 so that the plate has its center at (0,0). The build_plate routine is then called to create the geometry. Lines 50-52 If run in a separate process, make a socket connection to Marc Mentat.
Running the Script

Start Marc 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 Marc Mentat, and the values for these parameters will be obtained by the Python script to control the number of holes in the plate. Select the BUILD button to create the model.
CHAPTER 4
4-7
When the script completes, a plate will be created as shown in Figure 4-2.
.
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.
4-8
Chapter 5: PyMentat: Adding Model Properties
CHAPTER
Chapter Overview Plate Properties Node and Element Ids Running the Script Submitting the Job
5-2
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
CHAPTER 5
5-3
Plate Properties
As shown in the previous chapter, 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.
1000 Lb/in2
d height
d t=.75
fixed
d s d
d X
width
Figure 5-1
Plate with Varying Number of Holes
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.
5-4
This example is named chap5.py and can be found in the Marc Mentat directory examples/python/tutorial/c05. The following Python code has been added to the code shown in the previous chapter:
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 108 109 110 # check if f1 == f2 within tolerance of tol def check_tol(f1, f2, tol): if f1 == f2: return 1 if f1 + tol < f2: if f1 - tol > f2: return 1 return 0 def mesh_plate(width, height, diameter, spacing): 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 def add_bc(xs,ys,width,height): py_send("*renumber_all") n = py_get_int("nnodes()") # add fixed bc at left edge py_send("*apply_type fixed_displacement") py_send("*apply_dof x") py_send("*apply_dof y") py_send("*apply_dof z") 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)
CHAPTER 5
5-5
111 112 py_send("*add_apply_nodes ") 113 for i in range(0,len(node_list)): 114 str = "%d " % node_list[i] 115 py_send(str) 116 py_send(" # ") 117 # add edge load at top 118 py_send("*new_apply") 119 py_send("*apply_type edge_load") 120 py_send("*apply_value p 1000.0 ") 121 py_send("*add_apply_curves 3 #") 122 return 123 124 def add_matl(): 125 py_send("*material_type mechanical:isotropic") 126 py_send("*material_value isotropic:youngs_modulus 3e7 .3") 127 py_send("*add_material_elements all_existing") 128 return 129 130 def add_job(): 131 py_send("*loadcase_type static") 132 py_send("*job_class mechanical") 133 py_send("*job_option dimen:pstress") 134 py_send("*add_post_tensor stress") 135 py_send("*add_post_var von_mises") 136 py_send("*element_type 6 all_existing") 137 py_send("*element_type 6 all_existing") 138 return 139 140 def add_geom_prop(): 141 py_send("*geometry_type mech_planar_pstress ") 142 py_send("*geometry_value thick .75") 143 py_send("*add_geometry_elements all_existing") 144 return
5-6
145 146 def main(): 147 xs = 0.0 148 ys = 0.0 149 width = py_get_float("width") 150 height = py_get_float("height") 151 diameter = py_get_float("diameter") 152 spacing = py_get_float("spacing") 153 build_plate(xs,ys,width, height, diameter, spacing) 154 mesh_plate(width, height, diameter, spacing) 155 add_bc(xs,ys,width, height) 156 add_matl() 157 add_geom_prop() 158 add_job() 159 py_send("save_as_model chap5.mfd yes") 160 return 161 162 if __name__ == __main__: 163 py_connect("",40007) 164 main() 165 py_disconnect() 166
Lines 2-8
The check_tol routine is a convenience function to compare two floating point number for equality within a certain tolerance.
Lines 10-17 The mesh_plate routine will generate a 2-D planar Delaunay triangle mesh. To generate the curve divisions, the spacing between the holes is used to control the average length of the segments. Lines 19-46 The add_bc routine will create 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 will search through
CHAPTER 5
5-7
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). Lines 48-52 The add_matl routine will apply the material properties to all the elements of the plate. Lines 54-61 The add_job routine will create the necessary job parameters. Lines 63-67 The add_geom_prop routine will apply the necessary geometric properties. Lines 69-83 The main routine is similar to that of Chapter 4, however, the additional routines are called to add the boundary conditions, the material properties, the geometric properties and the job parameters.
5-8
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 will renumber 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
CHAPTER 5
5-9
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. 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 will return 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.
5-10
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 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.
CHAPTER 5
5-11
Figure 5-4
Resulting Mesh with Boundary Conditions Applied
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.
5-12
Chapter 6: PyMentat: Processing a Post File
CHAPTER
Chapter Overview Postprocessing Basics Scalar Values Running the Script
6-2
Chapter Overview
In this chapter, it will be demonstrated how to use the Postprocessing commands of Marc 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
CHAPTER 6
6-3
Postprocessing Basics
PyMentat may also be used to post process 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 Marc Mentat directory examples/python/tutorial/c06. The following is the Python code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 from py_mentat import * def main(): py_send("*post_close") py_send("*post_open chap6_job1.t16") py_send("*post_next") py_send("*fill_view") py_send("*post_contour_lines") n = py_get_int("nnodes()") # get number of nodes 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") max_scalars = [] 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:
6-4
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
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]) 52 print str 53 py_send( max_nodes[i] ) 54 py_send(" #") 55 py_send("*post_numerics") 56 return 57# Use database functions to find max/min 58 print " " 59 print " Label node scalar" 60 print " ------------------------------------------" 61 for i in range(0,len(label)): 62 str = "*post_value " + label[i]
CHAPTER 6
6-5
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
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 %g" % (label[i], n_id, d) print str return if __name__ == '__main__': py_connect('',40007) main() py_disconnect()
Lines 4-7
These statements open the post file and setup some options. We need to do a *post_next in line 6 so that we are at "increment 0" in Marc terminology. We need to tell Marc Mentat that we are working with scalar values, so one of the SCALAR PLOT commands need to be sent. This statement will get the number of nodes in the model. Note that this number may change at different increments due to rezoning.
Line 8 Line 10
Lines 11-17 A Python list is used to store the names of the nodal scalars that are in the post file. This is a convenient way of storing the names for use later. A Python list has an append method, and it is used to add the desired string to the list. Note that a Python list can be a list of anything, integers, floating points values, Python dictionaries or other lists.
6-6
Lines 19-20 The max_scalars and max_nodes variables are declared as Python Lists. The index of the list will be each of the scalars in the post file. The maximum scalar value will be stored in the max_scalars list. The node associated with the max_scalar value will be stored in the max_nodes list. Lines 21 The loop for all of the scalars in our list.
Lines 22-23 We append initial values to our list. Remember that max_scalars and max_nodes are linked lists, so we must have the item added to the list before we access it. Lines 24-25 Specify the scalar name to use. Lines 28 Loop through all the nodes. Note that we use a while loop for this. We had been using the Python range function, however, for the range function Python builds a list of all the values in the range. If we had 100,000 nodes, Python would build a list with that many items.
Lines 29-30 Obtain the node id for this node. Lines 31-32 Not all nodes in the post file are visible nodes. Some are nodes used explicitly by Marc to perform special functions and are considered "extra" nodes. The Database function post_node_extra will return 0 if a node is not an extra node, 1 if it is. This check is required to verify that the values obtained are true post file values at a node. Lines 33-34 Obtain the scalar value using the Database function scalar_1. Lines 35-36 We will use only positive values. If it is negative, then change it to positive. Lines 37-39 Check the current value against the highest value in our list. Line 43 Turn off the legend.
Lines 44-45 We need to remove all nodes from the post nodes list and then start the *post_nodes selection. Note that once the *post_nodes selection process has begun, we cannot call any of the py_get routines. Line 43 Start the *select_node command.
CHAPTER 6
6-7
Lines 47-52 Print out the results for each scalar. Line 53 Line 54 Line 55 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.
Line 58-76 This section uses the database functions to find the node with the maximum (or minimum) value. It loops through all the post values in the list, and then calls scalar_max_node and scalar_min_node to obtain the node number at which the largest and smallest values occur. It then calls the function scalar_1 to obtain the value associated with that node.
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 Marc Mentat directory examples/python/tutorial/c06 and run the Python script chap6.py. The output will appear as shown in Figure 6-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 6-1 Resulting Output from chap6.py
6-8
Figure 6-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
CHAPTER
Chapter Overview Database Properties Basics A Sample Script to Extract Data Running the Script Set Ids and Set Names
7-2
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
CHAPTER 7
7-3
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.
7-4
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 on page 4. 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.
CHAPTER 7
7-5
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 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 from py_mentat import * def main(): py_send("*new_model yes *open_model sets.mfd") m = py_get_int("nsets()") print "Found ",m," sets" 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 " edge number ",l else: print " "
7-6
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
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 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) p = py_get_float("material_par (%s,isotropic:youngs_modulus)" % sn) str = " Material %14s Type %19s Young's Mod %g" % (sn,st,p) print str mt = py_get_string("material_opt( %s,plasticity:method)" % sn) st = py_get_string("material_opt( %s,plasticity:yield)" % sn) str = " Plasticity method %9s Yield Surface %s" % (mt, st) 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)
CHAPTER 7
7-7
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
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) str = " Geometric Prop %12s Type %19s Thick %g" % (sn,st,p) 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) print str print "" sn = py_get_string("material_name()") print " Current material data: ", sn st = py_get_string("material_type(%s)" % sn) print " Type : ", st e = py_get_data( "material:isotropic:youngs_modulus") print " Youngs Modulus : ", e p = py_get_data( "material:isotropic:poissons_ratio") print " Poissons Ratio : ", p
7-8
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
ys = py_get_data("material:plasticity:yield_stress") print " Yield Stress : ", ys 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 " Contact Dist Tol : ", dt print "" sn = py_get_string("geom_name()") print " Current geometry data: ", sn thick = py_get_data("geometry:thick") print " Thickness : ", thick print "" m = py_get_int("nelements()") max_eid = py_get_int("max_element_id( )") print " Elements ", m, " Maximum id ", max_eid for i in range(1,m+1): id = py_get_int("element_id(%d)" % i) print "" 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)
CHAPTER 7
7-9
118 print " Contact Body 119 print " Geometry Property 120 print " Orientation 121 print " Material Property 122 123 return 124 125 if __name__ == '__main__': 126 py_connect('',40007) 127 main() 128 py_disconnect()
: : : :
", ", ", ",
cbn gmn orn mtn
Lines 3 Lines 5-6 Line 8 Line 9 Line 10 Line 11 Line 12 Line 14 Line 15 Line 16 Line 17
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 his 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.
Line 18-26 Depending on the set type, obtain the edge number or the face number if it is an edge or face set.
7-10
Line 28-34 Obtain the number of contact bodies. For each contact body, get the contact body name based on its index, 1 - ncbodys using the cbody_name_index database function. Supplying an index of 0 will return the current contact body name. Also obtained is the contact body index. Note from the output that the index and id are not identical. Line 36-74 In a manner similar to that for contact bodies, obtain the number of materials, boundary conditions, geometric properties and initial conditions. For each item, obtain the name using the index based name functions, xxx_name_index. Valid index values are from 1...m, where a value of 0 indicates the current item name. Note that in line 40 the function material_par is used to obtain a material parameter using a syntax similar to that used for py_get_data as described below. However, in the xxx_par methods the class token is not used. Line 76-99 This code displays how to obtain some values of the current material and contact table using the py_get_data function. The syntax for this function is basically the same that is used in the command that sets the value. In this example, the value obtained is 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.
CHAPTER 7
7-11
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.
7-12
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 will appear as shown in Figure 7-1 and Figure 7-2.
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
CHAPTER 7
7-13
Set
Set Set
Set 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
Figure 7-1
Set output from chap7.py
The database output is shown in Figure 7-2.
7-14
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
7-15
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
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
Figure 7-2
Database output from chap7.py
7-16
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
CHAPTER
Chapter Overview PyPost Basics Running the Script
8-2
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
CHAPTER 8
8-3
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 Marc 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:
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 Marc 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 2 3 4 5 6 7 8 9 10 11 12 13 from py_post import * def main(fname): p = post_open(fname) try: p.moveto(1) except: print Error opening post file: ,fname return max_scalars = [] max_nodes = [] nns = p.node_scalars()
8-4
14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
print "Found ", nns, " node scalars " for i in range(0,nns): max_scalars.append(-1.0e20) max_nodes.append(0) # find maximum nodal scalars 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 print " Label node scalar" print " ---------------------------------------" for i in range(0,nns): str = " %18s %10i %g" % (p.node_scalar_label(i), max_nodes[i],max_scalars[i]) print str return if __name__ == '__main__': main("../c06/chap5_job1.t16")
37 38 39 40 41
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.
CHAPTER 8
8-5
Lines 4-5
The max_scalars and max_nodes variables are declared as Python Lists. The index of the list will be each of the scalars in the post file. The maximum scalar value will be stored in the max_scalars list. The node associated with the max_scalar value will be stored in the max_nodes list. 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.
Line 7 Lines 4-8
Lines 10-11 The max_scalars and max_nodes variables are declared as Python Lists. The index of the list will be each of the scalars in the post file. Line 13 This statement will call the node_scalars method to obtain the total number of nodal scalars stored in the post file.
Lines 15-17 The lists are initialized. Line 20 Line 22 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).
Line 23
Line 24
Lines 25-26 Ignore the sign of the values and only work with magnitudes. Lines 27-29 Check the current value against the current maximum value. Convert the node sequence number to the node id using the node_id method. Lines 35-37 Print out the results for each scalar.
8-6
Running the Script

This script is intended to be run outside of Marc Mentat. In an X-terminal window or a Microsoft Windows command prompt window, change your directory to the Marc Mentat directory examples/python/tutorial/c08. Run the Python script chap8.py as:
python chap8.py
When the script completes, the output will printed as shown in Figure 8-1.
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 6
Figure 8-1
In the next chapter, we will begin working with element data.
Chapter 9: PyPost: Obtaining Element Data
CHAPTER
Chapter Overview Processing Element Data Running the Script
9-2
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. 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
CHAPTER 9
9-3
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 3 extrapolation methods available through the extrapolation method: linear Extrapolate by averaging the integration points to the centroid of the element and then doing a linear extrapolation from the centroid through the integration point to the node. 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.
translate
average
Consider the quadrilateral element shown Figure 9-1.

4 7 3 4 7 3
Eight node quadrilateral Node Integration pt

Figure 9-1
Four Gaussian integration points
Element Class 8: Eight Noded Isoparametric Quadrilateral Elements
9-4
The quadrilateral element of Figure 9-1 contains 8 nodes and 4 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 Marc Mentat directory examples/python/tutorial/c08. The following is the Python code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 from py_post import * def main(fname): p = post_open(fname) try: p.moveto(1) except: print Error opening post file: ,fname return max_scalars = [] max_nodes = [] max_incs = [] nns = p.node_scalars() nes = p.element_scalars() ninc = p.increments() print " Increments = ",ninc,", Nodal scalars = ",nns, ", 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):
CHAPTER 9
9-5
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 56 57 58
p.moveto(i) print "scanning increment ",i," post file number ",p.increment # find maximum nodal scalars 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 # find maximum element scalars j = 0 while j < nes: 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
9-6
59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
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 if __name__ == '__main__': main("../c06/chap5_job1.t16")
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.
Lines 4-8
Lines 10-12 The max_scalars, max_nodes, and max_incs variables are declared as Python Lists. The index of the list will be each of the scalars in the post file. The maximum scalar value will be stored in the max_scalars list. The node associated with the max_scalar value will be stored in the
CHAPTER 9
9-7
max_nodes list max_incs list.
and the associated increment will be stored in the
Lines 13-14 The node_scalars method is called to obtain the total number of nodal scalars and the element_scalars method is called to obtain the total number of element scales stored in the post file. Lines 19-22 The lists are initialized. Note that the lists contain both the nodal and element scalar data. Line 24 The outer loop is the one for the increments.
Lines 25-26 We call the moveto method with the current index number to step through the increments. Remember that the index number passed in the moveto method is not the same number as that which appears in the post file. In line 21, we print out the current index number, and the increment number as it appears in the post file. Lines 29-42 This is the nodal scalars section, which is the same as that of the previous chapter. Lines 45 Begin the loop for the element scalars.
Lines 48-49 Obtain the number of elements in the current increment. Rezoning may cause the number of elements to change between increments. Loop through all the elements. Line 50 Obtain the element scalars. The element_scalar method will return a list of PyScalar values. A PyScalar has two members: an id and a value. The id represents the node id, and value represents the scalar value. 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.
Line 53 Line 54
Lines 55-60 Check each value in the PyScalar list and compare them to the maximum values. Lines 65-74 Print out the results for each scalar.
9-8
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 Marc Mentat directory examples/python/tutorial/c09. Run the Python script chap9.py as:
python chap9.py
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
CHAPTER
10
Chapter Overview Processing Element Tensor Data Running the Script
10-2
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. 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
CHAPTER 10
10-3
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 Marc Mentat directory examples/python/tutorial/c10. The Python code is as follows:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 from py_post import * import sys class TensorData: def __init__(self, v, n, i): self.Value = v self.Node = n self.Inc = i def set_data(self, v,n,i): self.Value = v self.Node = n self.Inc = i def increment(self): return self.Inc def value(self): return self.Value def node(self): return self.Node def get_tensors(fname): p = post_open(fname) try: p.moveto(1) except: print Error opening post file: ,fname
10-4
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 56 57 58 59 60 61 62
return max_values = [] net = p.element_tensors() ninc = p.increments() print "Found ", net, " element tensors " print ninc, " increments " if net == 0 : print "Did not find element tensors" return for i in range(0,net): max_values.append(TensorData(0.0, 0, 0)) i = 1 while i < ninc: print "Scanning increment ",i p.moveto(i) j = 0 while j < net: k = 0 num = p.elements() while k < num: el = p.element_tensor(k,j) 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
CHAPTER 10
10-5
63 64 65 66 67 68 69 70 71 72 73 74
k = k + 1 j = j + 1 i = i + 1 # next increment
print " Item 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 def main(fname): get_tensors(fname) return if __name__ == '__main__': main(sys.argv[1])
75 76 77 78 79 80 81 82 83
Line 2 Lines 3-21 Line 24
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.
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
10-6
attempt to get any data from the post file, such as the number of element scalars available. Lines 33-34 The number of element tensors and the number of increments in the post file are obtained. Line 46 Line 53 Begin the increment loop. Obtain the number of elements in this increment. Rezoning may cause the number of elements to change between increments.
Lines 55-58 Obtain the list of PyTensors, and find the length of the list. Lines 58-61 For each item in the list, compare it to the maximum value. The set_data method of the TensorData class is used to set the values. Lines 71-75 Print the results. In line 69, the node method of the TensorData class is called to obtain the node id. Line 83 The filename is specified as the first argument to the script.
CHAPTER 10
10-7
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 Marc Mentat directory examples/python/tutorial/c10. Run the Python script chap10.py as:
python chap10.py chap10.t16
When the script completes, the output will appear 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
10-8
Chapter 11: PyMentat: Using the py_connect Method
CHAPTER
11
Chapter Overview Creating a Simple Python Script for Marc Mentat The py_connect Method Handling Socket Errors Running the Script
11-2
Chapter Overview
In this chapter, it will be demonstrated how to use Marc 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
CHAPTER 11
11-3

We will use the Python script shown in Chapter 3 which will create a simple element grid and use Marc Mentat PARAMETERS to control the size of the grid. This example is named chap3.py and can be found in the Marc Mentat directory examples/python/ tutorial/c03. The code is shown completely in Chapter 3, however, what we are interested in now is at lines 41-44 as follows:
41 42 43 44 if __name__ == __main__: 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 Marc 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 Marc Mentat to send commands and obtain parameters. It allows Marc 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 Marc 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 Marc 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.
11-4
All output from the Python script will appear in Marc 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.
Handling Socket Errors

Sometimes a socket may become unusable and Marc 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. Marc Mentat is started and the INITIATE CONNECTION button is selected. 2. In a separate window, a Python script makes a successful socket connection to Marc Mentat. 3. Marc Mentat exits before the Python script completes or calls the py_disconnect method. 4. Marc 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 2 3 4 5 6 import sys if __name__ == __main__: port = 40007 if len(sys.argv) > 1: port = sys.argv[1] py_connect("",port)
CHAPTER 11
11-5
7 8
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 Marc 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.
Figure 11-1
The Python Browser Window
11-6
Running the Script

First, start Marc 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 Marc 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 Chapter 3.
Chapter 12: PyPost: Plotting
CHAPTER
12
PyPost: Plotting
Chapter Overview Charting Script for Marc Mentat The Gnuplot Module The PyOpenGL Module
12-2
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.
CHAPTER 12
PyPost: Plotting
12-3
Charting Script for Marc 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 4 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 Marc Mentat directory examples/python/tutorial/ c12. The output from this example is a JPEG file name chap12a.jpg. The following is the Python code to use the gdchart module to create a JPEG plot.
1 from py_post import * 2 import gdchart 3 opt = gdchart.option 4 5 opt(set_color=(0xff8080, 0x8080ff, 0x80ff80)) 6 opt(bg_color=0xaaaaaa, plot_color=0x0000cd, line_color=0x000000) 7 size = (450, 450) 8 9 def do_plot(fname, t, Incs, dta): 10 opt(set_color=(0xff8080, 0x8080ff, 0x80ff80)) 11 opt(bg_color=0xaaaaaa, plot_color=0x0000cd, 12 line_color=0x000000,format=gdchart.GDC_JPEG) 13 opt(title=t, xtitle='Increment', ytitle=' Y-Displ',grid=1) 14 f=open(fname,wb) 15 gdchart.chart(gdchart.GDC_LINE, size, f, 16 Incs, dta[0], dta[1], dta[2], dta[3]) 17 f.close() 18 19 def main(fname): 20 p = post_open(fname) 21 p.moveto(1) 22 nns = p.node_scalars() 23 ninc = p.increments() 24 print " Increments = ",ninc
12-4
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 56 57
# The list of nodes to plot check_nodes = (42, 66, 78, 86) # Create an array for the displacements of # the nodes in the list displacements = [None]*len(check_nodes) for i in range(0,len(check_nodes)): displacements[i] = [0.0] * ninc Incs = [' '] * ninc nlocy = 0 for i in range(0,nns): s = p.node_scalar_label(i) if s == "Displacement Y" : nlocy = i for i in range(1, ninc): p.moveto(i) print "scanning post file increment ",p.increment Incs[i] = `p.increment` # get the Y displacements for specified nodes for k in range(0,len(check_nodes)): j = p.node_sequence(check_nodes[k]) displacements[k][i] = p.node_scalar (j,nlocy) title = "Nodes " for k in range(0,len(check_nodes)-1): title = title + `check_nodes[k]` + "," title = title + `check_nodes[len(check_nodes)-1]`
CHAPTER 12
PyPost: Plotting
12-5
58 59 60 61
do_plot("chapt12a.gif", title, Incs ,displacements) if __name__ == '__main__': main("../c09/chap9.t16")
Line 2 Lines 9-17
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.
Line 27
Lines 31-33 Create a two-dimensional array for the displacements. The list is the size [number of nodes to plot] x [number of increments]. Line 35 Create a string array for the increments.
Line 38-41 Find the index to the displacements for the node scalars. Line 43 Loop through all the increments.
Lines 49-51 Loop over the list of nodes to plot. Use the node_sequence routine to get the sequence number for the ids in the check_nodes list. Lines 53-56 Create the title for the plot. It will contain the list of the nodes used in the plot. In this example, you would run the script on the command line as:
python chap12a.py
The output from the script is shown in Figure 12-1.
12-6
Figure 12-1 The Resulting JPEG File from chap12a.py
CHAPTER 12
PyPost: Plotting
12-7
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 Marc Mentat. The gnuplot module will send commands to the Gnuplot program, and plots will 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 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 from py_post import * import os try: # Check if the package has been installed correctly import Gnuplot except: print "Gnuplot has not been installed" def gnu_plot(fname, title, Incs, dta, check_nodes): import time g = Gnuplot.Gnuplot(debug=1) 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 :
20 21 22 23 24 25
12-8
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 56 57 58
time.sleep(5) g.hardcopy(fname, color=1) # enhanced = 1 print '**** Saved plot to postscript file "%s" ****\n' % fname time.sleep(1) return def main(fname): p = post_open(fname) p.moveto(1) nns = p.node_scalars() ninc = p.increments() print " Increments = ",ninc check_nodes = (42,66,78, 86) displacements = [None]*len(check_nodes) for i in range(0,len(check_nodes)): displacements[i] = [0.0] * ninc Incs = [0] * ninc nlocy = 0 # find the index for the displacements for i in range(0,nns): s = p.node_scalar_label(i) if s == "Displacement Y" : nlocy = i for i in range(1, ninc): p.moveto(i) print "scanning post file increment ",p.increment Incs[i] = p.increment
CHAPTER 12
PyPost: Plotting
12-9
59 60 61 62 63 64 65 66 67 68 69
# 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) # k displacements[k][i] = dy gnu_plot("chap12b.ps", "Node Displacements", Incs, displacements, check_nodes) if __name__ == '__main__': main("chap12.t16")
Lines 4-8 Line 10 Line 12
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. Create the Gnuplot object.
Lines 14-15 Set the title, the linestyle, and the size of the plot. Line 16 Create an array to store the Gnuplot Data objects.
Line 18-19 Loop through each node in the ccheck_nodes list and create a title containing the node number and set the line color to a different color for each line. Lines 20-21 Set the x and y axis labels. Line 22 Call the plot routine to generate the plot. When the plot routine is called, the data is sent to the gnuplot program and the plot is displayed.
Line 23-26 If the platform is Microsoft Windows, pause the display. Otherwise wait for 5 seconds and then exit. Line 28 Create the postscript file.
12-10 Marc Python Tutorial
Line 30
Sleep (or pause) the program. If this is not done, a file will not be generated.
Lines 33-66 The main routine is similar to that of the chap12a.py example. When the script completes, a plot as shown in Figure 12-2 will be displayed in the Gnuplot program, and will be saved as a PostScript plot in the file chap12b.ps.
Figure 12-2 The Resulting PostScript File from chap12b.py
CHAPTER 12 12-11
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 example. It requires the PyOpenGL module and the Numeric extensions from LLNL.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 from from from from from py_post import * Numeric import * OpenGL.GL import * OpenGL.Tk import * OpenGL.GLUT import *
# list of the nodes to label check_nodes = [1,4,7,45] class Displ: def __init__(self, i, xv, yv, dxv, dyv): self.Id = i self.X = xv self.Y = 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
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 56 57 58 59 60 61
class Win: def __init__(self, left, right, bottom, top, w, h): self.Left = left self.Right = 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 def width(): return 400 def height(): return 400 def mode_3d(): global win glMatrixMode(GL_PROJECTION) glLoadIdentity() glOrtho(win.left(), win.right(), win.bottom(), win.top(), -1.0,1.0) glMatrixMode(GL_MODELVIEW)
CHAPTER 12 12-13
PyPost: Plotting
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
BMfonts = ( "glut9by15", "glut8by13", "glutTimesRoman10", "glutTimesRoman24", "glutHelvetica10", "glutHelvetica12", "glutHelvetica18" ) # draw a symbol for the node def draw_dot(x,y): dot = array([0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF]) glPixelStorei(GL_UNPACK_ALIGNMENT, 1) wid = 3 hei = 3 glRasterPos3f(x,y,0.0) t=dot.tostring() glDrawPixels(wid, hei, GL_RGBA, GL_UNSIGNED_BYTE, t) return def draw_string(str,x,y): glRasterPos3f(x,y,0.0) for i in range(len(str)): glutBitmapCharacter("glut9by15", ord(str[i])); return def draw_element(i): # draw the original shape 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() # draw the deformed shape glColor3f(0,1.0,0.0)
95 glBegin(GL_LINE_STRIP) 96 glVertex2f(nodedx[i], nodedy[i]) 97 glVertex2f(nodedx[i+1], nodedy[i+1]) 98 glVertex2f(nodedx[i+2], nodedy[i+2]) 99 glEnd() 100 return 101 102 def plot_nodes(lst): 103 global p 104 glColor3f(1,1,1) 105 for i in range(len(lst)): 106 j = p.node_sequence(lst[i]) 107 k=lst[i] 108 draw_string(`k`,nod[j].x(), nod[j].y()) 109 draw_dot(nod[j].x(), nod[j].y()) 110 dx = nod[j].x()+nod[j].dx() 111 dy = nod[j].y()+nod[j].dy() 112 draw_string(`k`,dx, dy) 113 draw_dot(dx,dy) 114 return 115 116 def draw_legend(): 117 global win 118 glColor3f(1,0,0) 119 glBegin(GL_LINE_STRIP) 120 x1 = win.left() + .1 121 x2 = x1 + (win.right()-win.left())/5.0 122 y = win.bottom() +.15 123 glVertex2f(x1, y) 124 glVertex2f(x2, y) 125 glEnd() 126 draw_string("undeformed", x2+.05, y) 127 glColor3f(0,1.0,0.0) 128 glBegin(GL_LINE_STRIP) 129 glVertex2f(x1, y-.1)
CHAPTER 12 12-15
PyPost: Plotting
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
glVertex2f(x2, y-.1) glEnd() draw_string("deformed",x2+.05, y-.1) return def redraw(o): glClearColor(0.1, 0.1, 0.1, 0) glColor3f(1,0,0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) mode_3d() glDisable(GL_LIGHTING) for i in range(0,len(nodex),3): draw_element(i) plot_nodes(check_nodes) draw_legend() glEnable(GL_LIGHTING) return def find_node(n,nod): for i in range(0,len(nod)): if nod[i].id() == n: return i return -1 def find_maxmin(x, y): global maxx, maxy, minx, miny if maxx < x : maxx = x if maxy < y : maxy = y if minx > x : minx = x if miny > y : miny = y def main(fname): global nodex, nodey, nodedx, nodedy global maxx, maxy, minx, miny
165 global nod # List of Displ objects 166 global win 167 global o, p 168 169 p = post_open(fname) 170 p.moveto(1) 171 nns = p.node_scalars() 172 173 ninc = p.increments() 174 print " Increments = ",ninc 175 176 # find the index ih the scalar label list for the displacements 177 for i in range(0,nns): 178 s = p.node_scalar_label(i) 179 if s == "Displacement X" : 180 nlocx = i 181 if s == "Displacement Y" : 182 nlocy = i 183 184 # go to the last increment 185 p.moveto(p.increments()-1) 186 k = 0 187 188 # get nodes 189 nod = [Displ] * p.nodes() 190 while k < n: 191 j = p.node_id(k) 192 i = k 193 np = p.node(k) 194 dx = p.node_scalar(k,nlocx) 195 dy = p.node_scalar(k,nlocy) 196 nod[k] = Displ(j,np.x, np.y,dx,dy) 197 k = k + 1 198
CHAPTER 12 12-17
PyPost: Plotting
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
k = 0 n = p.elements() # # # # Create the x and y coordinate arrays for plotting. We should check the element list to find out how many nodes are in each element. We know for this model all elements have 3 nodes. 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
224 225 226 227 228 229 # Generate the Win object containing the viewport info 230 minx = minx - .25*(maxx-minx) 231 maxx = maxx + .25*(maxx-minx)
cnt=0 # build the x and y coordinate arrays 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 k = k +1
232 233 234 235 236 237 238 239 240 241 242 243
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()
244 245 246 247 248 249 if __name__ == '__main__': 250 main("../c09/chap9.t16") 251
Line 2 Lines 3-5
Import the Numeric (NumPy) extension. Import the OpenGL, OpenGL toolkit (Tkinter), and the OpenGL GLUT modules.
Lines 10-26 Create a class for storing the displacement data. Lines 28-47 Create a class for storing information about the window. Lines 49-53 The width and height function to return the desired size. Change the values here to change the size of the window. Lines 55-60 The mode_3d routine will set the OpenGL parameters for a 3-D window.
CHAPTER 12 12-19
PyPost: Plotting
Lines 62-64 The BMfonts list contains the available fonts for displaying in the 3-D window. Lines 66-77 The drawdot routine will draw a 3x3 block of pixels. This is used to identify the nodes we wish to see labelled. Lines 79-83 The draw_string routine will draw a string of characters at the specified position in the 3-D window Lines 85-100The draw_element routine will draw both the deformed and the undeformed elements. Lines 102-114The plot_nodes routine will draw the "dot" to represent the node location and will label the node for both the deformed and undeformed elements. Lines 116-133The draw_legend routine will draw a legend in the lower left corner reflecting the color of the lines used for the deformed and undeformed shape. Lines 135-147The redraw routine is called by the Tkinter toolkit (which is registered at line 247) to redraw the window. It calls the mode_3d routine to setup the 3-D window, and then draws the elements, plots the nodes, and draws the legend. If the window is resized or receives an expose event, the toolkit will call this routine. Lines 149-153The find_node routine will find the index of a node id in the nod array. Lines 155-160The find_maxmin routine will find the maximum and minimum x and y values in the model. This is used to determine the values to specify when creating the 3-D window. Lines 163-167Declare some global variables. Lines 176-182Determine the index of the X and Y displacements in the post file. Lines 188-197Create an array of Displ objects to store the displacement data. Loop over all of the nodes and create an object. Lines 206-209Create the arrays to store the actual x and y coordinates to plot.
Line 215
Loop through all the elements.
Lines 217-226For each node in the element, get the index of the node in the nod array and store the data in the undeformed x and y arrays (nodex and nodey), and also in the deformed x and y arrays (nodedx and nodedy). The find_maxmin routine is called to find the maximum and minimum values so that the window may be scaled appropriately. Lines 229-234Find the minimum and maximum values for the data so that the window can be created with the proper limits. Lines 236-237Create the window frame using the Tkinter toolkit. Lines 238-242Create a quit button and a label that specifies the number of increments. Lines 243-247Create the OpenGL object and specify the width, height and whether double buffering is needed. Specify the redraw routine (line 244) and get the window focus. Then start the main loop event processing (line 247).
CHAPTER 12 12-21
PyPost: Plotting
Figure 12-3 The Resulting Plot from chap12c.py
Chapter 13: PyMentat: Menu System Lookup Functions
CHAPTER
13
Chapter Overview Menu System Lookup Functions Integer Function Double Function String Function Boolean Function State Function
13-2
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.
CHAPTER 13
13-3
Menu System Lookup Functions

This chapter describes how to obtain database value by accessing them using the menuing system lookup functions supported by Marc 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 Marc 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 will go directly to the menu item, however on Microsoft Windows you will 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 will be brought to the proper location which displays an integer database item displaying db_count_elements. For this case the function call will use 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 will 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.
13-4
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 non-zero 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)
CHAPTER 13
13-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 will be 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 }

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)
13-6
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 size 30 4 display post_file command *post_open }

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 2nd contact body in a model file:
str = py_ms_string(cbody_list_name, 1)
CHAPTER 13
13-7
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 will return 1 if the grid is on, false if it is off. The job_option example will return 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 4 states, so the state function should be used to get the active state.
13-8
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 }

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 will have a space after the name and will be 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
CHAPTER 13
13-9
Table B-1
State Functions Function Description *set_acis_formatted command state:

returns 0 if Acis file type is formatted, 1 if binary.
acis_file_type acis_file_check adapg_option adapg_param apply_option bsect_grid_type bsect_option carea_option cavity_option connect_option coord_system crdsyst_option crdsyst_type
*set_acis_entity_check command state:

returns 0 if entity check is off, 1 if on.
Returns 0 for rectangular, 1 for cylindrical
Coordinate system type: 0 for rectalngular, 1 for cylindrical, 2 for sphereical.
Coordinate system type: 0 for rectalngular, 1 for cylindrical, 2 for sphereical.
ctable_bodies_option ctable_entry curve_div_applyrest_state
*set_curve_div_applyrest_<cvs|lps>
command state: 0 = individual cuirves (cvs), 1 = detected loops (lps).
curve_div_tol_state geometry_option job_option job_post_eq_layers match_mesh_dir mesh_parameter_ mesh_split_method_1d
State of *set_curve_div_tol_(rel, abs) commands: 0=relative, 1=absolute.
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
mesh_split_method_2d mesh_split_method_3d numerics_format save_file_type select_filter select_method
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=assiciate, 7=point_dist, 8=curve_dist, 9=surface_dist 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=penta16 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=scatter 0=curve, 2=scatter 0=curve, 1=bar, 2=scatter
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
CHAPTER 13 13-11
set_import_space srfprop_option strline_option table_indep_vars
State of DXF file import for model/paper space: 0 is model, 1 is paper, 2 is both.
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.
table_xvar table_yvar tform_option weldpath_option xcv_discontinuous xcv_err_abs xcv_hyp_tc
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.
Chapter 14: MentatDCOM: Connecting to Mentat using a .NET Module
CHAPTER
14
Chapter Overview MentatDCOM Basics Running the Program MentatDCOM and PyMentat
14-2
Chapter Overview
In this chapter it will be demonstrated the basics of using the MentatDCOM module to connect to Marc 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
CHAPTER 14
14-3
MentatDCOM Basics
In chapter 2 it was shown how to use PyMentat to connect to Marc 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 Marc 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 using a DCOM interface which must be initiated in Marc Mentat 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();
VB.Net
Dim p as New MentatData()
14-4
The program example discussed in this chapter will be a C# program performing the same functions as shown in chapter 2.
1 using System; 2 using MentatDCOM; 3 namespace MentatTest 4 { 5 class Chap14 6 { 7 static MentatData p; 8 static void make_nodes(int s, int t, double xs, double ys) 9 { 10 int i, j; 11 double x, y, z, delx, dely; 12 y = ys; 13 z = 0.0; 14 delx = 1.0/(double)s; 15 dely = 1.0/(double)t; 16 string str; 17 for(i = 0; i < t; i++) 18 { 19 x = xs; 20 for(j = 0; j < s; j++) 21 { 22 str = "*add_nodes " + x.ToString() 23 + " " + y.ToString() + " " + z.ToString(); 24 25 p.send(str); 26 x = x + delx; 27 } 28 y = y + dely; 29 } 30 return; 31 } 32
CHAPTER 14
14-5
33 static void make_elements(int n, int m) 34 { 35 int i, j, n1, n2, n3, n4; 36 string str; 37 for(i = 1; i < m; i++) // the "y" dir 38 { 39 n1 = (i-1) * (n) + 1; 40 n2 = n1 + 1; 41 n4 = n1 + (n); 42 n3 = n2 + (n); 43 for(j = 1; j < n; j++ ) // the "x" dir 44 { 45 str = "*add_elements "+n1.ToString()+" " + 46 n2.ToString() + " " + n3.ToString() + " " + n4.ToString(); 47 p.send(str); 48 n1++; 49 n2++; 50 n3++; 51 n4++; 52 } 53 } 54 return; 55 } 56 57 static void Main(string[] args) 58 { 59 string host = "local"; 60 if (args.Length > 0){ 61 host = args[0]; 62 } 63 Console.WriteLine("chap14 {0}", host); 64 p = new MentatData(); 65 if (p.connect(host) > 0) 66 {
14-6
67 Console.WriteLine("Failed to connect to {0}", host); 68 return; 69 } 70 int n = 6; 71 int m = 8; 72 double xs = -1.0; 73 double ys = -1.0; 74 make_nodes(n, m, xs, ys); 75 make_elements(n, m); 76 p.disconnect(); 77 return; 78 } // end Main 79 } // end class 80 }
Lines 1-2
Import the modules to be used. The System module is required for using the WriteLine method, the MentatDCOM module provides access to the MentatData class. 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.
Lines 7 Lines 8-55
Lines 60-62 The argument list passed to the main function is checked for the host name. Line 64 The MentatData Object class is initialized. It creates the MentatData object and is stored in the variable p. All subsequent MentatDCOM methods called will be members of this object.
Lines 65-69 The connect method is called with the hostname of the computer. Lines 70-75 This code is similar to the Python code of chapter 2. Line 76 The disconnect method is called to close the connection.
CHAPTER 14
14-7
Running the Program

This script is intended to be run outside of Marc Mentat. In a Microsoft Windows command prompt window, change your directory to the Marc 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
The buildit.bat script will compile the program for you. Start Marc 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
14-8
MentatDCOM and PyMentat

The MentatDCOM module methods are very similar to those in PyMentat, however thre are some minor changes. connect(String ^host) This method is called py_connect in PyMentat. It initializes the connection to Marc 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
disconnect() This method is called py_disconnect in PyMentat and closes the DCOM connection.
p.disconnect();
send() This method is called py_send in PyMentat and sends a command string:
p.send(*set_grid on);
get_string() This method is called py_get_string in PyMentat and returns a string:

String ^nm = p.get_string(model_name()); Console::WriteLine({0}, nm);
get_double() This method is called py_get_float in PyMentat. It returns a type of double.

string s = element_mass(-1); double f = p.get_double(s); Console::WriteLine(Mass {0}, f);
get_int() This method is called py_get_int in PyMentat. It returns a type of integer.

string s = nnodes();
CHAPTER 14
14-9
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
CHAPTER
15
Chapter Overview MarcPost Basics Running the Program MarcPost and PyPost
15-2
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. 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
CHAPTER 15
15-3
MarcPost Basics
In Chapter 8 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 simliar 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()
The program example discussed in this chapter will be a C# program performing the same functions as shown in chapter 8.
1 2 using System; using MarcPost;
15-4
3 namespace MarcTest 4 { 5 class Chap15 6 { 7 static void Main(string[] args) 8 { 9 if (args.Length < 1){ 10 Console.WriteLine("CSPost requires filename"); 11 return 1; 12} 13 Console.WriteLine("CPost {0}", args[0]); 14 PostData p = new PostData(); 15 if (p.open(args[0]) > 0) 16 { 17 Console.WriteLine("Failed to open {0}", args[0]); 18 return; 19 } 20 p.moveto(1); 21 int nns = p.node_scalars(); 22 Console.WriteLine("Found {0} node scalars", nns); 23 double[] max_scalars = new double[nns]; 24 int[] max_nodes = new int[nns]; 25 int j, k, numnodes; 26 double d; 27 for(j=0;j<nns;j++) max_scalars[j] = -1.0e20; 28 for(j=0;j<nns;j++) 29 { 30 numnodes = p.nodes(); 31 for(k=0;k<numnodes;k++) 32 { 33 d = p.node_scalar(k,j); 34 if(d < 0.0) d = -d; 35 if(d > max_scalars[j]) 36 { 37 max_scalars[j] = d;
CHAPTER 15
15-5
38 max_nodes[j] = p.node_id(k); 39 } 40 } 41 } 42 Console.WriteLine(" Label node scalar"); 43 Console.WriteLine(" --------------------------------------------------"); 44 for(j=0;j<nns;j++) 45 { 46 Console.WriteLine(" {0,20} {1,10:d} {2,24:g}",p.node_scalar_label(j), 47 max_nodes[j], max_scalars[j]); 48 } 49 } // end Main 50 } // end class 51 }
Lines 1-2
Import the modules to be used. The System module is required for using the WriteLine method, the MarcPost module provides access to the PostData class. 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
Lines 9-12 Line 14
Lines 15-19 The open method is called with the post file name chap5_job1.t16. Line 20 Call the moveto method to go to the first increment. When the post file is opened it is at increment 0 which contains only the model data. We need to explicitly go to the first increment even though there is only one increment of data in the post file.
Lines 23-25 The max_scalars and max_nodes variables are declared as arrays. The index of the list will be each of the scalars in the post file. The maximum scalar value will be stored in the max_scalars list.
15-6
The node associated with the max_scalar value will be stored in the max_nodes list. Line 27 Line 28 Line 22 The max_scalars array is initialized. 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).
Line 28 Line 33
Lines 25-26 Ignore the sign of the values and only work with magnitudes. Lines 35-39 Check the current value against the current maximum value. Convert the node sequence number to the node id using the node_id method. Lines 44-48 Print out the results for each scalar.
CHAPTER 15
15-7
Running the Program

This script is intended to be run outside of Marc Mentat. In a Microsoft Windows command prompt window, change your directory to the Marc Mentat directory examples/python/tutorial/c15. Compile and run the C# program chap15.cs as:
csc /r:..\..\..\..\shlib\MarcPost.dll chap15.cs \ /out:chap15_cs.exe
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 6
Figure 15-1 Resulting Output from chap15.cs
15-8
MarcPost and PyPost

The MarcPost module methods are very similar to those in PyPost, however there are some differences. position() 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();
version() This method returns the MarcPost module version information:

String ^ver = p.version(); Console::WriteLine({0},ver);
Example output:
Assembly name MarcPost, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
Marc Python Reference
i-ii
MSC.Marc Python Reference
Introduction
Introduction
Using the Python Modules Variable Types
iv
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 Marc 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:
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 for examples on the use of these modules.
Variable Types
The type definitions for functions and methods used in this manual are as follows:
Introduction
Introduction
String
A character string. This type is similar to the C type of char, and the FORTRAN type of character*(*). A string may be specified by using either single quotes or double quotes.
Float
A floating point value. This is similar to the C type of double and the FORTRAN type of real*8.
Integer
An integer (or fixed point) value. This is similar to the C type of long int and the FORTRAN type of integer*8.
List
A Python List object. A Python list is essentially a linked list that can be accessed as an array.
vi
Chapter 1: PyMentat References
CHAPTER
PyMentat References
PyMentat py_connect py_disconnect py_echo py_get_data py_get_float py_get_int py_get_string py_prompt py_echo
1-2
PyMentat
This chapter describes the PyMentat routines.
PyMentat is the interface module for Python scripts to communicate to Marc Mentat. Marc Mentat must be running prior to invoking any PyMentat routine.
A Python script using PyMentat can be run either in embedded mode or run as a separate process. If invoked as a separate process, the py_port/py_connect routines must be the first PyMentat routines called.
All Python scripts that need access to the PyMentat module must import the module as: from py_mentat import *
CHAPTER 1
PyMentat References
1-3
py_connect
Name py_connect Summary Establishes a socket connection with Marc Mentat. Synopsis
py_connect(String hostname, Integer nPort)
Arguments hostname Hostname of system to make connection with nPort Description This routine will attempt to establish a socket connect with Marc 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 will be used. A Python script executed as a separate process would use this routine to enable it to communicate with Marc Mentat. It must be the first PyMentat function called. In addition, Marc Mentat should be waiting for a connection (the Marc Mentat command *py_connect should have been issued). Example
if __name__ == __main__: py_connect(127.0.0.1, 40007) main()
Port number
1-4
py_disconnect
Name py_disconnect Summary Terminates a socket connection with Marc Mentat. Synopsis
py_disconnect()
Arguments None Description This routine will terminate a socket connect with Marc Mentat after a successful connection with the py_connect routine. Example
if __name__ == __main__: py_connect(127.0.0.1, 40007) ... py_disconnect() main()
CHAPTER 1
PyMentat References
1-5
py_echo
Name py_echo Summary Enables/disables commands to be printed in Marc Mentats dialogue area using py_send. Synopsis
py_echo(int flag)
Arguments flag Description This routine affects command echoing in Marc Mentats dialogue area. If flag is set to true (a nonzero value), then the commands will be echoed. If flag is set to false (zero), then commands sent to Marc Mentat will not be echoed. This routine is most helpful in debugging Python scripts. The default setting is on. Note that enabling echo will slightly affect performance. Marc Mentat command echoing for Python scripts may also be enabled in Marc Mentat using the button:
UTILS->PYTHON->SCRIPT ECHO
An integer used to enable/disable echo.
Example
py_echo(0) py_echo(1) # disables echo # enables echo
1-6
py_get_data
Name py_get_data Summary Returns a floating point value from the database from the current data class. Synopsis
Float py_get_data(String name)
Arguments name Description This routine will parse the string specified in name and return 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
A string representing the database value to be returned.
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)
CHAPTER 1
PyMentat References
1-7
py_get_float
Name py_get_float Summary Evaluates an expression and returns a floating point value. Synopsis
Float py_get_float(String name)
Arguments name Description This routine will evaluate the expression specified in name and return 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 Marc Mentat and are not available to be used directly in the expression. Marc Mentat parameters may be defined and used for this purpose.
A string representing the expression to be evaluated.
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
1-8
py_get_int
Name py_get_int Summary Evaluates an expression and returns an integer value. Synopsis
Integer py_get_int(String name)
Arguments name Description This routine will evaluate the expression specified in name and return 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 Marc Mentat and are not available to be used directly in the expression. Marc Mentat parameters may be defined and used for this purpose.
A string representing the expression to be evaluated.
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
CHAPTER 1
PyMentat References
1-9
py_get_string
Name py_get_string Summary Evaluates a function or parameter and returns a string. Synopsis
String py_get_string(String name)
Arguments name Description This routine will evaluate the function or parameter specified in name and return 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 will interpreted as being the name of a PARAMETER that is currently defined and its expression will be returned.
Note: The variables created and used in the Python script are not stored by Marc Mentat and are not available to be used directly in the name argument. Marc Mentat PARAMETERS may be defined and used for this purpose.
A string representing the function or parameter to be returned.
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
1-10
py_prompt
Name py_prompt Summary Prints a string in the Marc Mentat dialogue area. Synopsis
py_prompt(String name)
Arguments name Description This routine will print the string name in the Marc Mentat dialogue area. Example
py_prompt(Evaluating Mesh)
The string to print in the dialogue area.
CHAPTER 1
PyMentat References
1-11
py_echo
Name py_echo Summary Enables/disables commands to be printed in Marc Mentats dialogue area using py_send. Synopsis
py_echo(int flag)
Arguments flag Description This routine affects command echoing in Marc Mentats dialogue area. If flag is set to true (a nonzero value), then the commands will be echoed. If flag is set to false (zero), then commands sent to Marc Mentat will not be echoed. This routine is most helpful in debugging Python scripts. The default setting is on. Note that enabling echo will slightly affect performance. Marc Mentat command echoing for Python scripts may also be enabled in Marc Mentat using the button:
UTILS->PYTHON->SCRIPT ECHO
An integer used to enable/disable echo.
Example
py_echo(0) py_echo(1) # disables echo # enables echo
1-12
Chapter 2: PyPost References
CHAPTER
PyPost References
PyPost close cbody cbody_angle cbody_displacement cbody_force cbody_moment cbody_name cbody_rotation
2-2
cbody_transform cbody_velocity cbody_volume cbodies domain element elements element_id element_scalar element_scalars element_scalar_label element_sequence element_tensor element_tensors element_tensor_label element_vector element_vectors element_vector_label extrapolation global_value global_values
CHAPTER 2
PyPost References
2-3
global_value_label 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 version
2-4
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 Description 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) The total creep strain energy The total damping energy
CHAPTER 2
PyPost References
2-5
elasticenergy energy kineticenergy plasticenergy thermalenergy strainenergy Variables buckle frequency
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 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 nonzero. 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
machangle pressure time mass volume Work appliedwork contactwork foundwork frictionwork springwork work
2-6
The PyPost module uses the following special types:

PyNode id x, y, z PyElement type len items PySet name type len items PyTensor id t11, t12, t13 Nodal Data the node id the x, y, z coordinates of the node Element Data the element type number of nodes in the element the list of node ids for the element Set Data 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 Tensor Data The node id of the tensor, if applicable First row of tensor matrix. These values in matrix notation would be t(1,1), t(1,2), and t(1,3) respectively. 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. Third row of tensor matrix. This value in matrix notation would be t(3,3). The tensor intensity Vector Data The node id of the vector, if applicable The x, y, z vector values Curve Data
t22, t23
t33 intensity PyVector id x,y,z PyCurve
CHAPTER 2
PyPost References
2-7
npoints norder points knots w PySurface npoints_u npoints_v norder_u norder_v points
Number of points Order of curve List of points that describe the curve (PyNode) Knot vector. The number of items is npoints+norder. Weight values. The number of items is npoints. Surface Data Number of points in u direction. Number of points in v direction. Order of surface in u direction. Order of surface in v direction. 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) List of weight values (floats). They are arranged in v major order similar to the points array. List of knot values (floats) in u direction. There are npoints_u+order_u items. List of knot values (floats) in v direction. There are npoints_v+order_v items. Number of trimming curves List of trimming curves (PyCurve). Contact Body Data The id of the contact body The name of the contact body
w knots_u knots_v ntrim trim PyContactBody id name
2-8
type
The type of the contact body: 0 - deformable 1 - 2d line elements (type 9) 2 - 3d patch elements (type 18) 3 - 2d curves 4 - 3d surfaces The physical type of the contact body: 1 - rigid 2 - deformable structural 3 - symmetry 4 - deformable heat-rigid 5 - workpiece (AutoForge) 6 - deformable acoustic The center of the contact body
bodytype
center_x center_y center_z axis_x axis_y axis_z npoints
The axis of the contact body
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.
points nelements
elements npatches
patches ncurves
CHAPTER 2
PyPost References
2-9
curves nsurfaces
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.
surfaces
2-10
close
Name close Summary Closes a currently open post file and frees any allocated memory. Synopsis
close()
Arguments None Description This method closes the post file associated with the PyPost object. Example
p = post_open(c08_job1.t19) p.close()
CHAPTER 2
PyPost References
2-11
cbody
Name cbody Summary Returns a PyContactBody object for a particular contact body. Synopsis
PyContactBody cbody(Integer index)
Arguments index Description Return a PyContactBody object for contact body index. The cbodies method should be called prior to calling the cbody method to obtain the total number of contact bodies that are available. The PyContactBody object contains the geometry for the contact body if the revision of the post file is 8 or higher (member revision of the PyPost object). This method returns a PyContactBody object.
PyContactBody Members id - contact body id name - name of the contact body (string) type - contact body type
Contact body index number
0 - deformable 1 - 2d line elements (line type 9) 2 - 3d patch elements (elem type 18) 3 - 2d curves 4 - 3d surfaces bodytype - physical type of contact body 1 - rigid 2 - deformable structure 3 - symmetry
2-12
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. - number of lines that comprise the contact body
- array of lines (PyPatchs) that comprise the contact body.

nlines lines
The point1 and point2 members of PyPatch are indices into the points array.

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. - number of point items - array of points (PyNodes) that comprise the contact body. - number of curve items - array of curves (PyCurves) that comprise the contact body. - number of surface items - array of surfaces (PySurfaces) that comprise the contact body.
If the contact body type is 1 or 2 the following are set:

npoints points

ncurves curves

nsurfaces surfaces
Prior to post revision 8, only rigid contact bodies have the following set:
center_x, center_y, center_z
- center of the contact body

axis_x, axis_y, axis_z
- axis of the contact body
See Also
cbodies, cbody_name
CHAPTER 2
PyPost References
2-13
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
2-14
cbody_angle
Name cbody_angle Summary Returns the angle for a particular contact body. Synopsis
Float cbody_angle(Integer index)
Arguments index 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. See Also
cbodies, cbody_name
cbody index number
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
PyPost References
2-15
cbody_displacement
Name cbody_displacement Summary Returns the displacement for a particular contact body. Synopsis
Float, Float, Float cbody_displacement(Integer index)
Arguments index 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. See Also
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)
2-16
cbody_force
Name cbody_force Summary Returns the x, y, and z force for a particular contact body. Synopsis
Float, Float, Float cbody_force(Integer index)
Arguments index 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. See Also
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
PyPost References
2-17
cbody_moment
Name cbody_moment Summary Returns the moment for a particular contact body. Synopsis
Float, Float, Float cbody_moment(Integer index)
Arguments index 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. See Also
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)
2-18
cbody_name
Name cbody_name Summary Returns the name of a particular contact body. Synopsis
String cbody_name(Integer index)
Arguments index 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. See Also
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
PyPost References
2-19
cbody_rotation
Name cbody_rotation Summary Returns the rotation for a particular contact body. Synopsis
Float cbody_rotation(Integer index)
Arguments index 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. See Also
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)
2-20
cbody_transform
Name cbody_transform Summary Returns the transform for a particular contact body. Synopsis
List Float cbody_transform(Integer index)
Arguments index Description Return the values of the transform for contact body index. The cbodies method should be called prior to calling the cbody_transform method to obtain the total number of contact bodies that are available. A transform is actually a 4x4 array of floats, however this method returns an array of 16 floats. They are arranged as follows: t( 0 ) T = t( 4 ) t( 8 ) t ( 12 ) See Also
cbodies, cbody_name
t(1) t(5) t(9) t ( 13 )
t(2) t(6) t ( 10 ) t ( 14 )
t( 3 ) t( 7 ) t ( 11 ) t ( 15 )
Example
p = post_open(ch03_job1.t16) p.moveto(1) print cbody_transform(p.cbodies()-1)
CHAPTER 2
PyPost References
2-21
cbody_velocity
Name cbody_velocity Summary Returns the velocity of a particular contact body. Synopsis
Float cbody_velocity(Integer index)
Arguments index 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. See Also
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)
2-22
cbody_volume
Name cbody_volume Summary Returns the volume of a particular contact body. Synopsis
Float cbody_volume(Integer index)
Arguments index 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. See Also
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
PyPost References
2-23
cbodies
Name cbodies Summary Returns the number of contact bodies. Synopsis
Integer cbodies()
Arguments None Description Returns the number of contact bodies. Example

p = post_open(c07_job1.t19) p.moveto(0) n = p.cbodies()
2-24
domain
Name domains Summary Returns the number of domains in the post file. Synopsis
Integer domains()
Arguments None Description Returns the number of domains in the post file. Example
p = post_open(c07_job1.t19) n = p.domains()
CHAPTER 2
PyPost References
2-25
element
Name element Summary Returns the element data for a particular element. Synopsis
PyElement element(int nelem)
Arguments nelem Description Returns a PyElement object containing the element data for element nelem in the current increment. This data may change for each increment due to rezoning.
PyElement Members type - element type len - number of nodes in the element items - list of node ids that comprise the element
The element index number
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
2-26
elements
Name elements Summary Returns the number of elements in the current increment. Synopsis
Integer elements()
Arguments None Description Returns the number of elements in the current increment. This may change for each increment due to rezoning. Example
p = post_open(c08_job1.t19) p.moveto(0) n = p.elements()
CHAPTER 2
PyPost References
2-27
element_id
Name element_id Summary Returns id of a particular element. Synopsis
Integer element_id(Integer nelem)
Arguments nelem Description Returns id of element at index number nelem. 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)
The element index number
2-28
element_scalar
Name element_scalar Summary Get a list of a particular element scalar for a particular element. Synopsis
List PyScalar element_scalar(Integer nelem, Integer ns)
Arguments nelem ns 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
Element index number Scalar index number
CHAPTER 2
PyPost References
2-29
element_scalars
Name element_scalars Summary Returns the number of element scalars available. Synopsis
Integer element_scalars()
Arguments None Description Returns the number of element scalars available. This method returns an integer. Example
P = post_open(c08_job1.t19) # print the element scalar labels p.moveto(1) n = p.element_scalars() for i in range(0,n): print p.element_scalar_label(i)
2-30
element_scalar_label
Name element_scalar_label Summary Returns the name of a particular element scalar. Synopsis
String element_scalar_label(Integer nscalar)
Arguments nscalar 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)
Scalar index number
CHAPTER 2
PyPost References
2-31
element_sequence
Name element_sequence Summary Returns index number of a particular element id. Synopsis
Integer element_sequence(Integer nelem)
Arguments nelem 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)
The element id
2-32
element_tensor
Name element_tensor Summary Get a list of a particular element tensors for a particular element. Synopsis
List PyTensor element_tensor(Integer nelem, Integer ntens)
Arguments nelem ntens Description Returns a list of nodes and nodal tensor values for element tensor ntens for element a 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]
Element index number Tensor index number
CHAPTER 2
PyPost References
2-33
element_tensors
Name element_tensors Summary Returns the number of element tensors available. Synopsis
Integer element_tensors()
Arguments None Description Returns the number of element tensors available. This method returns an integer. Example
P = post_open(c08_job1.t19) # print the element tensor labels p.moveto(1) n = p.element_tensors() for i in range(0,n): print p.element_tensor_label(i)
2-34
element_tensor_label
Name element_tensor_label Summary Returns the name of a particular element tensor. Synopsis
String element_tensor_label(Integer ntens)
Arguments ntens 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)
Tensor index number
CHAPTER 2
PyPost References
2-35
element_vector
Name element_vector Summary Get a list of a particular element vector for a particular element. Synopsis
List PyVector element_vector(Integer nelem, Integer nv)
Arguments nelem nv 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]
Element index number Vector index number
2-36
element_vectors
Name element_vectors Summary Returns the number of element vectors available. Synopsis
Integer element_vectors()
Arguments None Description Returns the number of element vectors available. This method returns an integer. Example
P = post_open(c08_job1.t19) # print the element vector labels p.moveto(1) n = p.element_vectors() for i in range(0,n): print p.element_vector_label(i)
CHAPTER 2
PyPost References
2-37
element_vector_label
Name element_vector_label Summary Returns the name of a particular element vector. Synopsis
String element_vector_label(Integer nscalar)
Arguments nvec 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)
Vector index number
2-38
extrapolation
Name extrapolation Summary Sets the integration point extrapolation method. Synopsis
extrapolation(String type)
Arguments type Description This method controls the manner in which element integration point data is extrapolated to the nodes of an element. In addition, they control the inter-element averaging of the nodal data after it has been extrapolated. The available methods are: linear Extrapolate by averaging the integration points to the centroid of the element and then doing a linear extrapolation from the centroid through the integration point to the node. 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. A string representing the integration method to use
translate
average
Example
P = post_open(c08_job1.t19) p.extrapolation(linear) print Extrapolation method is , p.extrapolate
CHAPTER 2
PyPost References
2-39
global_value
Name global_value Summary Returns the value of a particular global value. Synopsis
Float global_value(Integer index)
Arguments index Description Return the value of a particular global value index. This method returns a float. Example
# Post file from Userguide Example 3.5 p = post_open(airspring_axito3d_wcav_job1.t16) ninc = p.increments() p.moveto(ninc-1) n = p.global_values() for i in range(0,n): print p.global_value_label(i), : , p.global_value(i)
Global value index number
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
2-40
global_values
Name global_values Summary Returns the number of global values available. Synopsis
Integer global_values()
Arguments None Description Returns the number of global values available. This method returns an integer. Example
P = post_open(airspring_axito3d_wcav_job1.t16) # print the global value labels n = p.global_values() for i in range(0,n): print p.global_value_label(i)
CHAPTER 2
PyPost References
2-41
global_value_label
Name global_value_label Summary Returns the name of a particular global value. Synopsis
String global_value_label(Integer index)
Arguments index 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)
Global value index number
2-42
increments
Name increments Summary Returns the number of increments. Synopsis
Integer increments()
Arguments None Description 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 will return 2. Example
p = post_open(c08_job1.t19) n = p.increments()
CHAPTER 2
PyPost References
2-43
moveto
Name moveto Summary Moves to the specified increment in the post file. Synopsis
moveto(Integer i)
Arguments i Description Moves to the specified increment in the post file. Increment number 0 only contains the model itself. There is no scalar data for increment 0. The first increment with data is increment 1. When the moveto method is called, the following members of the PyPost object are available: increment time frequency Example
p = post_open(c07_job1.t19) p.moveto(4) print increment ,p.increment, Time ,p.time print Frequency ,p.frequency
increment number
increment number time of this increment frequency value of this increment
2-44
node
Name node Summary Returns the nodal data for a particular node. Synopsis
PyNode node(int nnode)
Arguments nnode Description Returns a PyNode object containing the nodal data for node at index nnode in the current increment. This data may change for each increment due to rezoning.
PyNode Members id x y z node id x coordinate y coordinate z coordinate
The node index number
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
PyPost References
2-45
nodes
Name nodes Summary Returns the number of nodes in the current increment. Synopsis
Integer nodes()
Arguments None Description Returns the number of nodes in the current increment. This may change for each increment due to rezoning. Example
p = post_open(c07_job1.t19) p.moveto(0) n = p.nodes()
2-46
node_displacement
Name node_displacement Summary Returns the nodal displacement values at a particular node. Synopsis
Float, Float, Float node_displacement(Integer index)
Arguments index 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. See Also
node_displacements
Node index number
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
PyPost References
2-47
node_displacements
Name node_displacements Summary 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"
2-48
node_id
Name node_id Summary Returns the id of a particular node. Synopsis
Integer node_id(Integer node)
Arguments node 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)
The node index number
CHAPTER 2
PyPost References
2-49
node_scalar
Name node_scalar Summary Returns the value of a particular node scalar at a particular node. Synopsis
Float node_scalar(Integer index, Integer scalar)
Arguments index scalar 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]
Node index number Scalar index number
2-50
node_scalars
Name node_scalars Summary Returns the number of node scalars available. Synopsis
Integer node_scalars()
Arguments None Description Returns the number of node scalars available. Example
# print the name of each scalar label p = post_open(c07_job1.t19) p.moveto(1) n = p.node_scalars() for i in range(0, n): print p.node_scalar_label(i)
CHAPTER 2
PyPost References
2-51
node_scalar_label
Name node_scalar_label Summary Returns the name of a particular scalar. Synopsis
String node_scalar_label(Integer index)
Arguments index 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)
Scalar index number
2-52
node_sequence
Name node_sequence Summary Returns index number of a particular node id. Synopsis
Integer node_sequence(Integer node)
Arguments node 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)
The node id
CHAPTER 2
PyPost References
2-53
node_vector
Name node_vector Summary Return the value of a particular node vector at a particular node. Synopsis
PyVector node_vector(Integer index, Integer nv)
Arguments index nv 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
Node index number Vector index number
2-54
node_vectors
Name node_vectors Summary Returns the number of node vectors available. Synopsis
Integer node_vectors()
Arguments None Description Returns the number of node vectors available. Example
# print the name of each vector label p = post_open(c07_job1.t19) p.moveto(1) n = p.node_vectors() for i in range(0, n): print p.node_vector_label(i)
CHAPTER 2
PyPost References
2-55
node_vector_label
Name node_vector_label Summary Returns the name of a particular node vector. Synopsis
String node_vector_label(Integer index)
Arguments index 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)
Vector index number
2-56
post_open
Name post_open Summary Open a postfile and return the PyPost object. Synopsis
PyPost post_open(String filename)
Arguments filename 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
Post file name.
- 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 - the increment number of post file time - the time for the current increment frequency - the frequency of this increment
Example
p1 = post_open(e7x14_solver0.t19) p1.moveto(0) p2 = post_open(e7x14_solver1.t19) p2.moveto(0) print Comparing ,p1.filename, to ,p2.filename
CHAPTER 2
PyPost References
2-57
set
Name set Summary Returns the data for a particular set. Synopsis
PyPostSet set(int nset)
Arguments nset Description Returns a PyPostSet object containing the set data for set nset in the models. Members
name type len items
The set index number
set name set type number of items in the set 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]
2-58
sets
Name sets Summary Returns the number of sets in the post file. Synopsis
Integer sets()
Arguments None Description Returns the number of sets in the post file. Example
p = post_open(c07_job1.t19) p.moveto(0) n = p.sets()
CHAPTER 2
PyPost References
2-59
title
Name title Summary Returns the title of the post file. Synopsis
String title()
Arguments None Description Returns the title of the model stored in the post file. This method returns a string. Example
# print the title p = post_open(c08_job1.t19) print Title: ,p.title()
2-60
version
Name version Summary Returns the version of the PyPost module. Synopsis
String version()
Arguments None Description Return the version string of the PyPost module. This method returns a string. Example
print PyPost version is ,version() p = post_open(c08_job1.t19)
Appendix A
Appendix A
Arithmetic and Database Functions

Arithmetic Functions Database Functions Utility Functions Set Functions
A-2

This chapter describes the Arithmetic and Database function supported by Marc 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
py_get_float Table A-1
The following are the Marc Mentat Arithmetic Functions which can be used in the or py_get_int functions or in a formula.
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) 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
Description
Appendix A
A-3
Table A-1
cosh(arg1) sinh(arg1) tanh(arg1) acosh(arg1) asinh(arg1) atanh(arg1) sqrt(arg1) rad(arg1) deg(arg1) abs(arg1) int(arg1) frac(arg1)
Arithmetic Functions (Continued)

Hyperbolic cosine of arg1 Hyperbolic sine of arg1 Hyperbolic tangent of arg1 Inverse hyperbolic cosine of arg1 Inverse hyperbolic sin of arg1 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) Distance in 3-D space between a point with coordinates (arg1,arg2,arg3) and a point with coordinates (arg4,arg5,arg6)
max(arg1,arg2) min(arg1,arg2) dist2d(arg1,arg2,arg3,arg4) dist3d(arg1,arg2,arg3,arg4, arg5,arg6)
A-4
Database Functions The following are the Marc 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 will need to be created from the database function and then used in the string command. For example:
*eval_define num nnodes() *job_title Model with $num nodes
will create an evaluated parameter named num using the nnodes() database function, and then use that in the *job_title command (note the use of the $ to signify it is the name of a parameter). The job title for the CONTACT demo would appear as:
Model with 72 nodes
Table A-2
Database Functions Function Description

Returns the name of the model file without the path. Returns the current directory. Returns the current model name. Returns the string for the base version (such as 2010). 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
filename() getcwd() model_name() revision version points() point_id(ARG1) max_point_id() point_surface_id(arg1) point_x(arg1) point_y(arg1) point_z(arg1) point_u1(arg1)
Appendix A
A-5
Table A-2
Database Functions (Continued)

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
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)
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 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
nsurfaces() surface_id(ARG1) max_surface_id() nsurface_curves(arg1) surface_curve_id(arg1, ARG2) 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)
A-6
Table A-2

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 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 Dimension of element arg1 (returns either 2 or 3)
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)
element_dimension(arg1)
Appendix A
A-7
Table A-2

Family of element arg1. Returns an integer: LINE = 1 TRIA = 2 QUAD = 3 HEX = 4 TETRA = 5 PENTA = 6 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. 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. Number of faces for element arg1 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. 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. 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_family(arg1)
element_edges(arg1) element_edge_area(arg1, ARG2)
element_edge_length(arg1, ARG2)
element_faces(arg1) element_face_area(arg1, ARG2)
element_face_volume(arg1, ARG2)
element_mass(arg1)
element_nodes(arg1) element_volume(arg1)
element_type(arg1)
element_type(element_id(-1))
element_cbody(arg1) Contact body name associated with element id arg1
A-8
Table A-2

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:
element_geom(arg1) element_material(arg1) element_orient(arg1) nadapgs() adapg_par(arg1,arg2)
adapg_par(adapg1,nelems)
adapg_name_index(ARG1) adapg_opt(arg1,arg2) Global remeshing criterion name of ARG1-th global remeshing criterion in database. Option string for option arg2 for the current global remeshing criterion named arg1. If arg1 is empty, then it uses the current global remeshing criterion. Example:
adapg_opt(adapg1,immediate_crit)
adapg_type(arg1) 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. Parameter values use same syntax as in the *apply_option command. Example:
apply_opt(apply1,ref_position)
apply_par_table(apply1,x) Parameter table name parameter named arg2 for the apply named arg1. If arg1 is empty, then it uses the current apply. Parameter values use same syntax as in the *apply_dof_table command Example:
apply_par_table(apply1,x)
apply_type(arg1) Boundary condition type for boundary condition named arg1. If arg1 is empty, then it uses the current boundary condition.
Appendix A
A-9
Table A-2

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(arg1,arg2)
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, 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>
A-10
Table A-2

Dof value named arg2 for the boundary condition named arg1. If arg1 is empty, then it uses the current boundary condition. Example:
apply_dof_val(arg1,arg2)
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_par(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. Parameter value 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 *contact_value command. Example:
cbody_par(cbody1,surf_div_u)
cbody_par_table(arg1,arg2) Parameter table name for param named arg2 for contact body named arg1. If arg1 is empty, then it uses the current contact body. Parameter values use same syntax as in the *cbody_param_table command. Example:
cbody_par_table(cbody1,filmk)
cbody_type(arg1) Contact body type for contact body named arg1. If arg1 is empty, then it uses the current contact body.
Appendix A A-11
Table A-2

Parameter value named arg2 for the contact body named arg1. If arg1 is empty, then it uses the current contact body. Example:
cbody_par(arg1,arg2)
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) niconds() icond_name_index(ARG1) icond_opt(arg1,arg2) 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. 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) icond_dof_val(arg1,arg2) Initial condition type for icond arg1. If arg1 is empty, then it uses the current initial condition. Dof value named arg2 for the initial condition named arg1. If arg1 is empty, then it uses the current initial condition. Example:
icond_dof_val(icond1,x)
icond_name() 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) Number of geometric properties in the database Returns the name of the current geometric property Geometic property name of ARG1-th geometry in database.
A-12
Table A-2

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(arg1,arg2)
geom_opt(material3,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(material3,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(material3,thick)
geom_type(arg1) job_par(arg1,arg2) Geometric property type for geometry arg1. If arg1 is empty, then it uses the current geometry. 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,
Appendix A A-13
Table A-2

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, 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. Example:
lcase_par(lcase1,trans_x)
Valid parameters: abscurrent, angle<0..5>, anneal_temp, bcond_pen_mp, before_bdc_<x|y|z>, beta, buckle_tol, charge, cooling_time,
A-14
Table A-2

cornering_velocity, crank_length, creeptime, current, cutoff_stress, cutter_rapid_speed, cycle_time, 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() nmaterials() material_name_index(ARG1) material_par(arg1,arg2)
Returns the title of the current loadcase. Number of materials in the database. Material name of ARG1-th material in database. 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 *material_value command. Example:
material_par(material3,isotropic:youngs_ modulus)
Appendix A A-15
Table A-2

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 *material_param_table command. Example:
material_par_table(arg1,arg2)
material_par_table(material3,isotropic: youngs_modulus)
material_opt(arg1,arg2) Option string for option named arg2 for material named arg1. If arg1 is empty, then it uses the current material. Option strings use same syntax as in the *material_option command. Example:
material_opt(material3,plasticity:method)
material_type(arg1) material_name() mesh_par(arg1) Material type for material named arg1. If arg1 is empty, then it uses the current material. Returns the name of the current material. 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
A-16
Table A-2

mesher_type self_contact shrink_factor ties write_extended
pm_par(arg1)
Returns parameter string named arg1. Example:
pm_par(arg1)
Example:
*define aa MyText pm_par(aa)

pr_par(arg1) Program data parameter value named arg1. Example:
pr_par(curve_div_maxl)
Valid parameters: curve_div_<maxl|minl|type|ndiv|tol|rest> curve_div_tol_abs mesh_cv_div_avgl mesh_<min|max|param>_tol intersect_tol relative_tol sweep_tolerance, overlay_ndiv_<x|y> nlinks() nservos() nsprings() nties() link_class(arg1) tie_type(arg1) link_name_index(ARG1) link_name() tie_name() servo_name() spring_name() 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.
Appendix A A-17
Table A-2

Spring parameter value named arg1 for the current spring. Example:
spring_par(arg1)
spring_par(damping)
Valid parameters: conductivity current damping dynamic_force flux heat init_force static_forcet stiffness spring_par_table(arg1,arg2) Spring table name for value named arg2 for lin named arg1. If arg1 is empty, then it uses the current spring. Parameter values use same syntax as in the *spring_param_table command. Example:
spring_par_table(link2,stiffness)
spring_opt(arg1,arg2) Option string for option named arg2 for spring named arg1. If arg1 is empty, then it uses the current spring. Option strings use same syntax as in the *spring_option command. Example:
geom_opt(link2,spring_type)
norients() orient_name() orient_name_index(ARG1) orient_type(arg1) ntforms() tform_name() tform_name_index(ARG1) tform_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. 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.
A-18
Table A-2
wz_par(arg1

SuperForm Wizard parameter value named arg1. Example:
wz_par(length)
Valid parameters: angle diam elmax elmin fric fric_class heatcoef height length mvx mvy mvz num rep rotx roty rotx temp thick type1 type2 type3 type4 width wz_str(arg1) SuperForm Wizard string value named arg1. Example:
wz_str(tool_name)
Valid parameters: die cat_string tool_name workpiece wp_name
Appendix A A-19
Utility Functions The following are the Marc Mentat Utility Functions which can be used in the py_get_float, py_get_int or py_get_string functions.
Table A-3 Utility Functions Function
range(arg1,arg2,arg3)
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) Same as range except that arg3 (the increment value) is set as 1. Aspect ratio of element arg1 as computed by the
range2(arg1,arg2) element_aspect_ratio(arg1) element_distortion(arg1) element_inside_out(arg1) element_upside_down(arg1) element_attach_curve(arg1, ARG2) element_attach_surface(arg1, ARG2) node_point_id(arg1) curve_x(arg1, u) curve_y(arg1, u) curve_z(arg1, u)
*check_aspect command
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 Returns the id of the surface to which the ARG2-th face of element arg1 is attached, 0 otherwise 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
A-20
Table A-3
Utility Functions (Continued)

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.
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)
Appendix A A-21
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.
Table A-4 Post File Database Functions Function
displace_x(arg1) displace_y(arg1) displace_z(arg1) post_data(name)
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(time) post_data(work)
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_x(arg1)
A-22
Table A-4
Post File Database Functions Function Description

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. 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.
vector_y(arg1)
vector_z(arg1)
add_disp(arg1, arg2)
add_displ_x(arg1, arg2)
add_displ_y(arg1, arg2)
add_displ_z(arg1, arg2)
scale_disp(arg1, arg2)
scale_displ_x(arg1, arg2)
Appendix A A-23
Table A-4
Post File Database Functions Function Description

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.
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)
A-24
Set Functions The following are the Marc Mentat Set functions which can be used in a call to the py_get_float or py_get_int functions. The set_name and set_type functions return a string and must be used in a call to the py_get_string function.
Table A-5 Set Functions Function
is_curve_set(arg1) is_edge_set(arg1) is_element_set(arg1) is_face_set(arg1) is_node_set(arg1) 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)
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. 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.

MARC Tutorials

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

MARC Tutorials

Enviado por

Direitos autorais:

Formatos disponíveis

Marc Python 2010

Tutorial and Reference Manual

Marc Python Tutorial Chapter

Marc Python Tutorial and Reference Manual

Set Ids and Set Names . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7-16

Marc Python Tutorial and Reference Manual

Marc Python Reference Introduction

Using the Python Modules . . . . . . . . . . . . . . . . . . . . . . . . . . i-iv

Marc Python Tutorial and Reference Manual

MSC.Marc Python Tutorial

Marc Python Tutorial

Organization of this Manual Contents of the Chapters Documentation Conventions

Marc Python Tutorial

Organization of this Manual

Contents of the Chapters

PART I Chapter 2 Chapter 3

PART II Chapter 8 Chapter 9 Chapter 10

PART III Chapter 11 Chapter 12

Marc Python Tutorial

Marc Python Tutorial

The Basics of Using PyMentat

GENERATE TEST MODEL

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

mentat.proc is created when Marc Mentat is run

DEVELOP AND MODIFY PYTHON SCRIPT

Add new commands as needed in the script

Marc Python Tutorial

The Basics of Using PyPost

Marc Python Tutorial

A Brief Look at Python Programming

The block of FORTRAN code would need to be coded as follows in Python:

Marc Python Tutorial

Chapter 2: PyMentat: A Simple Example

PyMentat: A Simple Example

Marc Python Tutorial

Creating a Simple Python Script for Marc Mentat

Marc Python Tutorial

def main(): n = 6 m = 8 xs = -1.0 ys = -1.0 make_nodes(n,m,xs,ys) make_elements(n,m) return

Python Programming Hints

Marc Python Tutorial

Running the Script

Python Menu Screen

The Python Browser Window

Marc Python Tutorial

Python Menu Screen with a Created Mesh

Chapter 3: PyMentat: Obtaining Data from Mentat

PyMentat: Obtaining Data from Marc Mentat

Marc Python Tutorial

Creating a Simple Python Script for Marc Mentat

Marc Python Tutorial

The py_get_int and py_get_float methods

Running the Script

Marc Python Tutorial

Chapter 4: PyMentat: Building Complex Geometry

PyMentat: Building Complex Geometry

Chapter Overview Background Information Running the Script

Marc Python Tutorial

Plate with varying Number of Holes

Marc Python Tutorial

Marc Python Tutorial

Running the Script

Resulting Plate with Holes

Marc Python Tutorial

Chapter 5: PyMentat: Adding Model Properties