ABAQUS二次开发教程.doc

ABAQUS（Python语言）二次开发教程

ABAQUS（Python语言）二次开发
人生苦短，我用Python
作者：Fan Shengbao

Python2.7
2017年12月

16

目 录
第一章 Python程序基本语法 1
1.1 Python语法结构 1
1.2 Python元组 1
1.3 Python列表 1
1.4 Python字典 2
1.5 Python集合 3
1.6 Python字符串 3
1.7 Python分支语句 4
1.8 Python循环语句 5
1.8.1 for循环 5
1.8.2 while循环 5
1.9 Python定义函数 5
1.10 Python模块 6
1.11 Python包 7
1.12 Python文件和目录 7
1.12.1 目录操作 7
1.12.2 文件操作 7
1.13 Python异常处理 8
第二章 ABAQUS/Python二次开发 9
2.1 ABAQUS执行Python程序 9
2.2 编写ABAQUS/Python程序 10
2.3 ABAQUS录制Python程序 10
2.4 ABAQUS/Python对象介绍 11
2.4.1 session对象 11
2.4.2 mdb对象 11
2.4.3 odb对象 13
2.5 ABAQUS完整二次开发示例 14
2.6 ABAQUS二次开发常用函数 16
2.6.1 Part模块常用函数 16

ABAQUS（Python语言）二次开发教程
第一章 Python程序基本语法
1.1 Python语法结构
Python语言以缩进来约束每个程序块，编写程序时要特别注意每一行的缩进量，同一层次的语句应具有相同的缩进量。下面是一段Python程序示例：
#-*- coding:utf-8 -*-
for i in range(1,10):
for j in range(1,i+1):
print str(j)+'x'+str(i)+' = '+str(i*j),
print
该段程序主要功能是实现乘法口诀表输出打印，其中“#-*- coding:utf-8 -*-”是约定文档的编码方式。程序主体部分由两个嵌套的for循环语句组成，可以看到每一个for循环块的内部都具有相同的缩进量。程序输出结果如下：
1x1=1
1x2=2 2x2=4
1x3=3 2x3=6 3x3=9
1x4=4 2x4=8 3x4=12 4x4=16
1x5=5 2x5=10 3x5=15 4x5=20 5x5=25
1x6=6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36
1x7=7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49
1x8=8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64
1x9=9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81
Python程序中一行中“#”号后面的内容为注释，“#”号只支持单行注释，多行注释可使用“’’’ … ‘’’”注释符。
'''
Abaqus6.14 Python
'''
1.2 Python元组
Python中的元组（tuple）相当于C语言中的数组简化版，其内容和长度均不可变，只能对其内容进行访问。
tt1 = (1,2,3,4,5)
print tt1[1]
程序执行结果：
2
1.3 Python列表
Python中的列表（list）相当于C语言中的数组，但比C语言中的数组使用起来更加方便灵活。其长度和内容均可修改，列表是编程时使用较多的结构。
list1 = [1,2,3,4,5]
print list1[1]
list1[1] = 5
print list1
list1.append(6)
print list1
程序执行结果：
2
[1, 5, 3, 4, 5]
[1, 5, 3, 4, 5, 6]
Python列表常用操作方法：
表 11 Python列表常用操作方法
操作方法
功能
list1.append()
list1.append(1) 在列表末尾追加元素
list1.extend()
list1.extend([7,8,9]) 合并两个列表
list1.insert()
list1.insert(2, ’1’) 在列表指定位置插入元素
list1.pop()
list1.pop(n) 输出并删除指定位置的元素，不指定n值时则弹出末尾元素
list1.index)
list1.index(5) 在列表中搜索该元素第一次出现的位置
list1.count()
list1.count(1) 在列表中搜索该元素出现的次数
list1.reverse()
list1.reverse() 反转列表排序，也可使用list1[::-1]
list1.sort()
list1.sort() 对列表进行排序
对列表进行切片操作（元组也能进行相应的操作）：
list1 = [1,2,'3','a','b',5]
print list1[2:4]
print list1[2:]
print list1[1::2]
print list1[:-2]
输出结果：
['3', 'a']
['3', 'a', 'b', 5]
[2, 'a', 5]
[1, 2, '3', 'a']
1.4 Python字典
Python中的字典（dict）对于存储数据非常有用，其存储的数据是无序的，每一个键对应着一个键值，是一种映射型数据类型。
dict1 = {'author':'Fan Shengbao','software':'Abaqus'}
dict1['data'] = '2017' #添加一个字典元素
print dict1['software'] #打印‘software’键的键值
print dict1.keys() #打印所有键
print dict1.values() #打印所有的键值
print dict1.items() #打印所有键及其键值
程序输出结果：
Abaqus
['software', 'Data', 'author']
['Abaqus', '2017', 'Fan Shengbao']
[('software','Abaqus'),('Data','2017'),('author','Fan Shengbao')]
从打印的结果可以看出，字典的存储是无顺序的。获取字典键值需通过键来访问，键是唯一的，多个键可以对应相同的内容。
1.5 Python集合
Python中集合（set）的概念来源于数学在的集合，集合中的每个元素都是唯一存在，多次添加同一元素只存在一个。集合区别于列表和元组，其不能通过下表进行访问，但可以将其转换位列表后再进行其他操作。
set1 = set('abcde')
print set1
set1.add('f') #添加’f’元素
set1.add('b') #添加’b’元素
print set1
print list(set1)
输出结果：
set(['a', 'c', 'b', 'e', 'd'])

set(['a', 'c', 'b', 'e', 'd', 'f'])
['a', 'c', 'b', 'e', 'd', 'f']
Python中集合常见操作方法：
表12 Python中集合常见操作方法
操作方法
功能
list1 – list2
list1与list2的差集
list1 & list2
list1与list2的交集
list1 | list2
list1与list2的并集
list1.add()
list1.add(‘a’)向list1中添加一个元素
list1.updata()
list1.updata([1,2,3])向list1中添加多个元素
list1.remove()
list1.remove(‘a’)移除list1中的’a’元素
1.6 Python字符串
Python中的字符串是一种只能访问的数据类型，定义之后不能对其内容进行修改，否则程序将抛出异常。
str1 = 'Abaqus 6.14 Python'
print str1[0:6]
print str1.center(30,'-')
程序运行结果：
Abaqus
------Abaqus 6.14 Python------
Python字符串常见操作方法：
表13 Python字符串常见操作方法
操作方法
功能
str1.find()
str1.find(substr,start,end) 从str1中搜索substr，不指定start和end时指搜索整个字符串，可以只单独指定start
str1.count()
str1.count(substr,start,end) 获取字符出现次数
str1.startswith()
str1.startswith(str) 是否以str开始
str1.endswith()
str1.endswith(str) 是否以str结尾
str1.center()
str1.center(n,char) 以str1为中心获取n个字符，不够部分使用char填充
str1.ljust()
str1.ljust(n,char) 以str1为左对齐获取n个字符，不够部分使用char填充
str1.rjust()
str1.rjust(n,char) 以str1为右对齐获取n个字符，不够部分使用char填充
str1.upper()
将str1全部转换为大写
str1.lower()
将str1全部转换为小写
str1.replace()
str1.replace(old,new,count) count为替换次数，若省略只替换一次
str1.strip()
str1.strip(char) 去除str1前后的char，若省略则去除前后空格
str1.split()
str1.split(sep,maxcount) 以sep分割字符串，maxcount为最大分割次数（可省略），省略sep则使用空格进行分割
1.7 Python分支语句
if分支语句有以下三种基本形式，可根据不同情况选用不同的形式，使用时需替换pass占位语句：
形式一
形式二
形式三
if condition:
pass
if condition:
pass
else:
pass
if condition1:
pass
elif condition2:
pass
else:
pass
1.8 Python循环语句
Python编程语言只包含两种循环结构，分别是for循环和while循环。for循环要比while循环使用更加频繁。
1.8.1 for循环
1) for循环主体结构：
for i in range(1,10):
pass
else:
pass
其中pass为占位符，else可省略，else只有在for循环不是由break中断的情况下才会执行else下的语句。
2) for循环可遍历元组、列表和字符串：
for i in [1,2,3,4,5]:
print i
3) for具有一些比较高级的迭代功能（比普通循环更加高效，执行速度更快）：
print [i*i for i in range(10)]
print [(i,j) for i in range(3) for j in range(3) if i!= j]
程序执行结果：
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
1.8.2 while循环
while循环主体结构：
i = 0
while i<10:
pass
i += 1
else:
pass
1.9 Python定义函数
Python语言定义函数采用def进行声明，函数体需进行统一缩进。Python函数常用的有两种：参数有默认值的函数和参数无默认值的函数，函数参数某一个带默认参数时，其后的参数也需带默认值。
#参数无默认值
def FunName1(arg1,arg2):
return arg1+arg2
#给参数指定默认值
def FunName2(arg1,arg2=1):
return arg1+arg2
#函数调用
print FunName1(1,2) #返回3
print FunName2(1) #返回2
print FunName21,2) #返回3
Python语言也有一些自带的函数：
表 14 Python自带函数
函数名
功能
abs()
abs(-1) 求一个数的绝对值
sum()
sum([1,2,3]) 求一个列表的和，等于6.0
max()
max([1,2,3]) 求一个列表的最大值，等于3
min()
min([1,2,3]) 求一个列表的最小值，等于1
range()
range(start,end,step) 产生一个列表包含start，但不包含end，增量为step（可省略）
xrange()
xrange(start,end,step) 和range()函数一样，但其初始时只生成一部分，一般用在循环次数较多的情况下，能够减少循环时间。
type()
type(var) 检测变量或内容的类型
input()
input() 接受一个输入，ABAQUS软件中Python的默认输入函数有两个：一个为单输入函数getInput(title,default)；另一个为多输入函数getInputs(((title1,default1),( title2,default2),…))，其中title和default为字符串，且default可省略。
len()
len(…) 参数可以是元组、列表或字符串，功能是检测其长度
all()
all(…) 检测参数，都不为0或‘’，返回True，否则返回False
any()
any(…) 检测参数，任一不为0或‘’，返回True，否则返回False
注：表中只列举了部分直接访问的函数，Python标准库中包含着许多函数，如math库。
1.10 Python模块
Python模块就是一个py文件，文件中可包含变量、函数和类。可在另一个py文件中导入该模块，调用其中的函数。
导入模块的方法：
①import ModelName
②from ModelName import FunName
导入自建模块时，需注意Python的搜索路径，只有将模块放入搜索路径中，才能通过以上方法导入Python模块。可通过以下代码查看当前Python编辑器的搜索路径和添加目录到Python的搜索路径：
import sys
print sys.path #打印Python的搜索路径
sys.path.append('D:\\...') #将“D:\\...”添加到搜索路径中
1.11 Python包
Python包由一个初始化文件“__init__.py”及一个或多个函数文件（模块文件）组成，将这些python文件放入同一个文件夹下就构成了一个Python包。包中的“__init__.py”文件用来申明包中包含的模块文件。如图所示为一个包的文件构成：

图1.1 Python包文件构成
__init__.py文件包含的内容如下：
__author__ = "Fan Shengbao"
__all__ = ['openOdbFile','getMaxStress','getMaxDisplacement']
其他文件中均包含着对应的函数
导入模块的方法（包文件夹需放入Python的搜索路径之下）：
①单个函数导入：from PythonPackageName import getMaxStress
②一次全部导入：from PythonPackageName import *
1.12 Python文件和目录
1.12.1 目录操作
获取当前工作目录和更改当前工作目录：
import os
print os.getcwd() #获取当前工作目录
os.chdir('D:\\') #更改当前工作目录
获取指定目录下的某种类型文件，可以使用一个Python的标准库glob，代码实例如下：
import glob
print glob.glob('D:\\*.odb') #获取所有的odb文件
print glob.glob('D:\\name.*') #所有以name为名的文件
1.12.2 文件操作
打开和关闭文件：
file = open('D:\\1.txt') #打开文件，也可指定打开方式（r、w等）
file.close() #关闭文件
读写文件内容：
通常读文件时使用一条语句读取全部内容，并将每一行内容独立存入列表中，具体示例代码如下：
f = open('D:\\1.txt').read().split('\n').strip()
也可以使用下表所示的读写文件函数进行读写操作，Python还有其他的一些读写操作函数未列举在表中。
表15 文件读写函数
函数
功能
read()
一次性读取全部内容
readline()
每次读取一行内容
readlinesnum)
每次读取num行内容
write()
写文件，参数为一个字符串，可包含换行符
writelines()
写多行，参数为一个列表，换行添加‘\n’
1.13 Python异常处理
Python异常处理能够规避程序执行错误，当程序出错时能够进行相应的处理或者直接忽略错误继续执行程序。
异常处理结构（pass可以替换为相应的代码）：
try:
pass
except ErrorType:
pass
finally:
pass
将可能出错的代码放入try代码行下面，except后接指定的错误类型或不指定（接受所有错误），当指定错误发生时程序执行except下的程序，最后执行finally下的程序。

第二章 ABAQUS/Python二次开发
2.1 ABAQUS执行Python程序
ABAQUS执行Python程序的方法可以找百度，下图为ABAQUS软件自带的编译器PDE，可用于调试Python程序，支持断点调试。

图 2.1 ABAQUS软件PDE编辑器
常用的ABAQUS软件执行Python方法：
① File—>Run Script…再选择需要运行的Python程序文件
② 直接在宏程序里面编写程序，再调用宏管理器（File—>Macro Manager…）执行程序
③ 只写几行代码的话，可以到ABAQUS软件底部的kernel command line interface中编写

图2.2 kernel command line interface窗口
2.2 编写ABAQUS/Python程序
下面是一个ABAQUS/Python程序的简单例子：该段程序生成如图所示的三维模型，并导入到装配模块中。
#-*- coding:utf-8 -*-
from abaqus import *
#导入Abaqus常量模块
from abaqusConstants import *
#导入Abaqus中常用的模块，例如step，material……
from caeModules import *

#新建一个Model并命名为Model-1
model1 = mdb.Model(name='Model-1')

#创建一个三维可变形实体，并命名为Part-1
part1 = model1.Part(name='Part-1',dimensionality=THREE_D,
type=DEFORMABLE_BODY)

#创建一个名为Sketch-1的草图
skt = model1.ConstrainedSketch(name='Sketch-1',sheetSize=100)
#在创建的草图中绘制一个矩形
skt.rectangle(point1=(-50,-50),point2=(50,50))
#在草图中心绘制一个R=25的圆
skt. CircleByCenterPerimeter(center=(0,0),point1=(25,0))
#对草图skt进行拉伸，指定深度为50
part1.BaseSolidExtrude(sketch=skt,depth=50)
asm = model1.rootAssembly #访问装配模块
#将新建的part1添加到装配中
asm.Instance(name='Part-1-1',part=part1,dependent=ON)
2.3 ABAQUS录制Python程序
使用宏管理器可以将对ABAQUS的操作录制成Python程序，通过宏录制可缩短程序开发时间，方便对ABAQUS软件进行二次开发。稍加修改录制后的程序，就能得到想要的效果。
下图为ABAQUS软件的宏管理器（File—>Macro Manager…）：

图2.3 ABAQUS软件宏管理器
点击Create…能够对ABAQUS软件的操作进行录制，生成Python代码并添加到宏管理器中，某些情况下需对程序进行一定的编辑才能重复出录制的操作，直接运行可能得不到与之前操作一样的结果或者程序直接报错。
2.4 ABAQUS/Python对象介绍
2.4.1 session对象
session模块主要用来控制窗口显示属性，例如新建多个窗口、设置窗口大小、调整当前显示窗口和打开odb文件等。录制程序时会出现多行以session开头的语句，但其中大部分记录的是我们调整视图的操作，例如转动或平移一下模型，编辑时可删除这些语句。
获取当前显示的窗口名称：
viewportName = session.currentViewportName
获取当前显示的窗口的model名称：
viewportName = session.currentViewportName
modelName=session.viewports[viewportName].displayedObject.modelName
新建一个窗口：
session.Viewport(name = 'Viewport: 2')
2.4.2 mdb对象
mdb对象是ABAQUS前处理中最为重要的一个对象，是一个顶层对象，下面包含着丰富的子对象和方法。
表 21 mdb对象信息
成员类型
名称
功能
构造函数
Mdb()
生成一个新的模型数据库
成员函数
openMdb()
新建一个cae文件，参数为cae文件完整路径
mdb.close()
关闭当前cae文件，并不保存
mdb.save()
保存当前cae文件
mdb.saveAs()
另存为cae文件，参数为另存cae文件的完整路径
mdb.Model()
生成一个model，参数为model名
……
……
成员变量
mdb.jobs()
当前模型创建的所有job
mdb.models()
当前模型所有的model
……
……
每个cae文件包含一个或多个Model，大部分前处理信息均包含在每个Model下面，通过mdb.models[modelName]可单独访问每个Model下的数据。通过每个Model可继续访问之下的part、material和rootAssembly等。

图 2.4 Model下的部分对象

Python在前处理中，可以用来建立复杂的三维模型，下面程序建立了一个三维函数曲面图，数学公式如式2.1所示，代码如下：
（2.1）
#程序开始
#-*- coding:utf-8 -*-
from abaqus import *
from abaqusConstants import *
from caeModules import *
import math

part1 = mdb.models['Model-1'].Part(name='Part-1',
dimensionality=THREE_D,type=DEFORMABLE_BODY)
point_U = []
point_Utemp = None
point_V = []
point_Vtemp = []

for i in range(-100,100):
point_V.append([])

for i in xrange(-100,100):
point_U = []
for j in xrange(-100,100):
x = 0.025*i
y = 0.025*j
coord = (x,y,3*x*math.exp(-x**2-y**2))
point_U.append(coord)
point_V[j+100].append(coord)

part1.WireSpline(points=point_U, mergeType=MERGE,
meshable=ON, smoothClosedSpline=ON)
for i in point_V:
part1.WireSpline(points=i mergeType=MERGE,
meshable=ON, smoothClosedSpline=ON)

part2 = mdb.models['Model-1'].Part(name='Part-2',
dimensionality=THREE_D,type=DEFORMABLE_BODY)
edges = []
for i in point_V:
part2.WireSpline(points=i, mergeType=MERGE,
meshable=ON, smoothClosedSpline=ON)
for i in point_V:
edges.append((part2.edges.findAt(i[0]),))

part2.ShellLoft(loftsections=(edges), startCondition=NONE,
endCondition=NONE)

asm = mdb.models['Model-1'].rootAssembly
asm.Instance(name='Part-1-1',part=part1,dependent=ON)
asm.Instance(name='Part-2-1',part=part2,dependent=ON)
session.viewports['Viewport: 1'].setValues(displayedObject=asm)
该程序生成两个三维模型，如图所示：

图2.5 线框模型 图2.6 曲面模型
2.4.3 odb对象
odb对象和mdb对象有很多的相似性，包含的对象和访问方式也几近相同。下面代码可用于读取指定odb文件的最后分析步的最大应力并打印显示出来：
def readMaxStress(myViewport, jobName):
path = os.getcwd()
o1 = session.openOdb(name=path+'\\'+jobName+'.odb')
myViewport.setValues(displayedObject=o1)
myViewport.odbDisplay.setPrimaryVariable(variableLabel='S',
outputPosition=INTEGRATION_POINT, refinement=(
INVARIANT, 'Mises'), )
myViewport.odbDisplay.display.setValues(plotState=(
UNDEFORMED, ))
myViewport.odbDisplay.display.setValues(plotState=(
CONTOURS_ON_DEF, ))
print myViewport.odbDisplay.contourOptions.autoMaxValue

2.5 ABAQUS完整二次开发示例
该段程序实现了平板拉伸应力分析，完成了从建模、添加边界条件载荷、监控计算状态和应力自动读取完整分析过程。
#-*- coding:utf-8 -*-
from abaqus import *
from abaqusConstants import *
from caeModules import *
import os
import __main__

def PlateTensile(h,w,r,t,f):
#检测输入是否正确
if r>=h/2.0:
print "Error: Radius > Height"
return False
if r>=w/2.0:
print "Error: Radius > width"
return False
if r<=0 or t <= 0 or f == 0:
print "ERROR!!!"
return False
#创建名为‘Model-1’的模型对象
model = mdb.Model(name = 'Model-1')
part = model.Part(name='Part-1',dimensionality=THREE_D,
type=DEFORMABLE_BODY)
asm = model.rootAssembly
skt1 = model.ConstrainedSketch(name='Skt1',sheetSize=200)
skt1.rectangle(point1=(-w/2.0,-h/2.0),point2=(w/2.0,h/2.0))
skt1.CircleByCenterPerimeter(center=(0,0),point1=(r,0))
part.BaseShell(sketch = skt1)
session.viewports['Viewport: 1'].setValues(displayedObject=part)

model.Material(name='Material-1')
model.materials['Material-1'].Elastic(table=((210000.0, 0.3),))
model.HomogeneousShellSection(name='Section-1',preIntegrate=OFF,
material='Material-1', thicknessType=UNIFORM,thickness=t,
thicknessField='', idealization=NO_IDEALIZATION,
poissonDefinition=DEFAULT, thicknessModulus=None,
temperature=GRADIENT,useDensity=OFF,
integrationRule=SIMPSON, numIntPts=5)
f1 = part.faces
region = regionToolset.Region(faces=f1)
part.SectionAssignment(region=region, sectionName='Section-1',
offset=0.0, offsetType=MIDDLE_SURFACE, offsetField='',
thicknessAssignment=FROM_SECTION)

asm.Instance(name='Part-1-1', part=part, dependent=ON)
model.StaticStep(name='Step-1', previous='Initial')
s1 = asm.instances['Part-1-1'].edges
edges1 = s1.findAt(((w/2.0,0,0),))
edges2 = s1.findAt(((-w/2.0,0,0),))
rp1 = asm.ReferencePoint(point=(w/2.0,0,0))
region1 = regionToolset.Region(edges=edges1)
region2=regionToolset.Region(referencePoints=(
asm.referencePoints[rp1.id],))