Python在ABAQUS二次开发中的应用实例2..
基于Python的ABAQUS二次开发在骨钻削仿真中的应用
基于Python的ABAQUS二次开发在骨钻削仿真中的应用陈春城;胡亚辉;郑清春;张善青【期刊名称】《现代制造工程》【年(卷),期】2018(000)006【摘要】在骨外科手术中,骨钻孔占据了重要地位,而钻孔温度更是影响骨细胞坏死的重要因素.为了研究在钻孔过程中不同因素对温度的影响,基于ABAQUS有限元软件进行仿真,采用Python脚本语言对ABAQUS软件的前处理模块进行优化,修改钻削模型的Python脚本程序,创建了参数化的骨钻削模型.有效地简化了建立模型的繁琐过程,且建立了友好的人机界面,为用户仿真提供了便捷的分析设计平台.通过实验验证了该功能的可行性,为后续研究不同的钻削用量对钻削温度的影响奠定了基础.【总页数】5页(P54-57,113)【作者】陈春城;胡亚辉;郑清春;张善青【作者单位】天津市先进机电系统设计与智能控制重点实验室,天津300384;天津理工大学,天津300384;天津市先进机电系统设计与智能控制重点实验室,天津300384;天津理工大学,天津300384;天津市先进机电系统设计与智能控制重点实验室,天津300384;天津理工大学,天津300384;天津市先进机电系统设计与智能控制重点实验室,天津300384;天津理工大学,天津300384【正文语种】中文【中图分类】TH164【相关文献】1.基于Python的Abaqus二次开发在空间可展单簧片结构仿真分析中的应用 [J], 叶红玲;胡腾;赵春华;肖燕妮2.基于Python的Abaqus二次开发在层压板修理模拟中的应用 [J], 郭霞;关志东;刘遂;陈萍;刘佳;王欣晶;邱太文3.基于Python/ABAQUS二次开发在创建变速器内部传动系有限元模型的应用 [J], 王金明;邓小梅4.基于Python的ABAQUS二次开发在飞机蒙皮锤铆中的应用 [J], 陈彦海;秦运海;姜春英;康玉祥;叶长龙5.基于Python的ABAQUS二次开发在复合材料层合板冲击建模中的应用 [J], 陈芳育;李进;邱玮桢;吕泉江因版权原因,仅展示原文概要,查看原文内容请购买。
Abaqus里应用Python的一些技巧
Abaqus里应用Python的一些技巧例如:cell4 = mdb.models['block'].parts['crankcase'].cells[4],要把part模块中编号为4的体赋值给cell4,就需通过路径mdb→models→part→cells(4号体属性),其中'block'、'crankcase'、分别是model和part的名字。
在草图Sketch中画线:s = mdb.models[' block '].ConstrainedSketch(name='grid',sheetSize=3.0)s.Line(point1=(-1.275, 0.0), point2=(-1.125, 0.0))s.Line(point1=(1.125, 0.0), point2=(1.275, 0.0))执行任何一条命令都必须按照结构树的格式进行操作。
我们所看到的python脚本繁杂的语句就是这样形成的。
这样大量的命令不能在短时间内掌握,我们只需要根据自己的需要边建立模型边学习就可以了。
a = mdb.models['Model-1'].rootAssemblys = a.instances['Mount-1'].edgesside1Edges = s.findAt(((0.0475, 0.0, 0.0), ))以上三行与下面的句子是等同的,即把findat找到的edges赋值给side1Edges。
分开来写简单明了,大大缩短了语句的长度。
side1Edges = mdb.models['Model-1'].rootAssembly. instances['Mount-1'].edges. findAt(((0.0475, 0.0, 0.0), ))a.Surface(side1Edges=side1Edges, name='Bottom'),这行语句设置side1Edges所对应的edge为名称'Bottom'的surface的set。
python abaqus 二次开发 循环提交作业
Python是一种高级编程语言,它在科学计算、数据分析、人工智能等领域有着广泛的应用。
Abaqus是一款常用的商业有限元软件,它主要用于工程结构分析和仿真。
二次开发是指在现有软件的基础上,使用编程语言对软件进行扩展和定制化。
1. Python在Abaqus二次开发中的应用在Abaqus软件中,Python被作为主要的二次开发语言来使用。
用户可以利用Python对Abaqus进行自动化操作、批量处理、数据分析等工作。
Python的简洁语法和强大的库支持,使得Abaqus二次开发变得更加高效和灵活。
2. Abaqus中的循环提交作业在Abaqus中,循环提交作业是指对多个任务进行批量处理的操作。
用户需要对多个模型进行相似的分析,可以利用循环提交作业的方式来提高分析效率。
通过编写Python脚本,可以实现循环读取模型文件并提交分析任务的功能。
3. Python在循环提交作业中的应用Python在Abaqus中循环提交作业的过程中发挥着重要的作用。
用户可以利用Python脚本来实现对多个模型的批量处理,节约时间和人力成本。
Python的循环结构和文件操作能力,使得循环提交作业变得更加简单和高效。
4. 二次开发与循环提交作业的结合通过Python的二次开发功能,用户可以定制化地实现循环提交作业的功能。
用户可以编写Python脚本来实现针对特定工程需求的循环提交作业流程,提高软件的灵活性和适用性。
二次开发也可以使得循环提交作业的过程更加智能化和自动化。
5. 实例分析以某工程仿真为例,用户需要对多个零件进行疲劳分析。
通过Python的二次开发,用户可以编写循环提交作业的脚本,实现自动读取不同零件模型并提交分析任务的功能。
这样一来,用户无需手动逐个提交任务,极大地提高了分析工作的效率。
Python在Abaqus的二次开发中能够很好地支持循环提交作业的功能。
通过二次开发,用户可以定制化地实现循环提交作业的流程,提高软件的适用性和工作效率。
从记录到编程--Python在ABAQUS程序化参数化建模分析中的应用
region152=a.surfaces['CP‐76‐sup_A26']
## face set 转换成 region
......
......
mdb.models['Model‐1'].SurfaceToSurfaceContactStd(name='CP‐76‐beam2_A2‐sup_A26', ##region 之间建立接触对
下面介绍一个光伏行业的系统级别安装模型(图 1)。该模型是一个很大的光伏组件阵列的一部分,组件 (panel)的倾角为 20 度,并且安装在一个钢铁支架系统上。该模型是完全通过 Python 编程建立起来的,
2
Байду номын сангаас
2010 ABAQUS Users’ Conference (China)
是一个参数化的分析模型。由于篇幅有限,本文只介绍其中一个 part 即 sup 的建立过程。Python 程序如 下,所涉及的各种函数均是本人自行编写的。
Keywords: Python; Secondary development; General Contacts
1、前言
通常建立有限元模型的时候,往往先借助其他三维制图软件(Pro/E, SolidWorks, CATIA, UG 等)生成 几何模型,然后将几何模型导入到 ABAQUS CAE 环境中,根据需要进行模型修复、处理,然后进行网格划 分建立有限元模型。由于软件的兼容性以及有限元模型与几何模型的差异性,在 ABAQUS 中进行几何模型 修复也可能比较困难。于是有人连模型修复、网格划分都在第三方软件中进行(如上述制图软件和 HyperMesh 等网格划分软件)。在 ABAQUS 中建立分析步、建立接触对和施加约束、载荷条件后,在提交运 算之前生成 INP 文件以便保存模型。该 INP 文件(包括对 INP 文件的修改之后生成的新的 INP 文件)也可 以用于提交运算。
基于Python的Abaqus前、后处理GUI插件二次开发与应用
基于Python的Abaqus前、后处理GUI插件二次开发与应用作者:***来源:《计算机辅助工程》2022年第02期摘要:为提高Abaqus建模效率并进行可视化数据分析,利用Python语言对Abaqus前-后处理进行二次开发。
分析某柴油机机油-水冷却器模块组件,结果表明:前处理模块开发螺栓GUI插件,能够批量创建相同规格的螺栓载荷,提高前期建模效率,缩短分析周期;后处理模块开发Campbell制图插件,能根据工程实际需要将模态结果数据绘制成Campbell图,并将计算结果可视化输出。
关键词: Abaqus; Python; 二次开发; 前处理; 后处理; GUI界面中图分类号: TP391.99; TB115.1文献标志码: BGUI plugin redevelopment and application of Abaquspre-and post-processing based on PythonTIAN Yutai(Shanghai New Power Automotive Technology Co., Ltd., Shanghai 200438, China)Abstract: To improve the efficiency of Abaqus modeling and achieve visual data analysis,redevelopment of Abaqus pre-and post-processing is carried out with Python language. A diesel engine oil-water cooler module is analyzed. The results show that: a bolt GUI plug-in is developed for the pre-processing module, which can create bolt loads of the same specification in bulk,improving pre-modeling efficiency and shortening the analysis cycle; the Campbell mapping plug-in is investigated for the post-processing module, which can draw the modal result data into Campbell diagrams according to the actual needs of engineering and visualize the calculation results for output.Key words: Abaqus;Python; redevelopment; pre-processing;post-processing; GUI interface0引言作为国际通用计算分析软件,Abaqus具有丰富的单元类型与材料非线性模型,在各领域发挥至关重要的作用。
ABAQUS前_后处理模块二次开发的应用
ABAQUS有限元程序通过集成 Python语言向二次 开发者提供了很多库函数 , 通过 ABAQUS 脚本接口 (ABAQUS Scrip ting In2terface) , Python语言调用这些库 函数来增强 ABAQUS的交互式操作功能 。它允许用户 绕过 ABAQUS /CAE的 GU I( graphical user interfaces)直 接与内核交互 , 可以大大提高工作效率或完成 ABAQUS /CAE没有提供的功能 。但是因为它没有通 过 GU I,显的不那么直观 ,而且如想改变某些参数就不 得不修改脚本程序 ,这些对一般用户来说就显的比较 麻烦 。因此 , 对 ABAQUS 二次开发一般应先开发 出 GU I后 ,让 用 户 输 入 或 选 择 有 关 参 数 后 , 然 后 生 成 ABAQUS的脚本语言来自动处理 。ABAQUS的 GU I是 用 ABAQUS GU I Toolkit来编 写 , 它 也是 对 FOX GU I
chongyaDB 模块的作用是应用 ABAQUS GU I Tool2 kit来完成对图 4 的界面的排序功能 ,并调用 Icons模
·32·
块或相关图片 。本例中在此使用是调用图片 ,如果 ,要 使用调用 Icons模块的方法则要用 XPM 图片数据作为 Python的字符列表来定义 icon,这样比较麻烦 ,尤其对 于复杂的图形 。 (注 : ABAQUS GU I Toolkit支持以下几 种格式来创建 icon: ①XPM 格式 ; ②BM P 格式 ; ③GIF 格式 ; ④PNG格式 ,而后三种格式是一般的绘图软件就 支持的格式 ,如 w indow s自带的画图软件就支持后三
2 应用举例
ABAQUS二次开发-Python脚本运行方式
ABAQUS二次开发—Python编程语言
1.1 ABAQUS软件界面下运行Python脚本 方式2:
点击“File”=>“Run Script…”弹出选择Python脚本文件,点击“OK”后直接运行
ABAQUS二次开发—Python编程语言
1.1 ABAQUS软件界面下运行Python脚本 方式3:
方式2:启动ABAQUS/Viewer界面的同时运行Python脚本 abaqus viewer script=D:\myPython.py abaqus viewer startup=D:\myPython.py
注:方式2中的Python脚本只能进行后处理过程,否则一 个错误将发生
ABAQUS二次开发—Python编程语言
点击“File”=>“Macro Manager…”弹出选择Python宏文件,点击“Run”后运行
ABAQUS二次开ห้องสมุดไป่ตู้—Python编程语言
1.1 ABAQUS软件界面下运行Python脚本
方式4:
2
1
4
3
1 打开Python脚本文件 2 选择要执行的脚本 3 选择执行脚本的方式 4 运行脚本文件
1.2 以命令行形式运行ABAQUS/Python脚本
方式3:不启动ABAQUS/CAE 界面的同时运行Python脚本 abaqus cae noGUI=D:\myPython.py
方式4:不启动ABAQUS/Viewer界面的同时运行Python脚本 abaqus viewer noGUI=D:\myPython.py
注:ABAQUS软件界面不会出现,脚本文件中的任何打印 输出将被忽略。适用于生成cae或直接提交计算 的脚本文件。
Python在ABAQUS二次开发中的应用实例.ppt
File → Run Script,打开相应的.py文件,即可执行; 刚打开ABAQUS界面,直接选择Run Script也可; 可以在GUI界面下部的命令行接口输入脚本语句执行。
ABAQUS 脚本概述
创建ABAQUS脚本
➢ 创建脚本有3种常用方法: ➢ ①在GUI建模时录制宏(macro)
Python在ABAQUS二次开发中 的应用实例
主要内容
• 一、ABAQUS 脚本概述 • 二、Python 语言简介 • 三、ABAQUS脚本编写
一、ABAQUS 脚本概述
ABAQUS 脚本概述
ABAQUS软件简介
➢ ABAQUS是国际著名的CAE软件,它以解决实际工业问题能力和强大 的非线性功能赢得广泛声誉。航空工业是ABAQUS最重要的应用领域 之一,波音、空中客车、洛克希德•马丁等是其长期合作的用户。
句,需要用分号分开。如:x=1;y=2;z=3。如果一个逻辑语句太长需要分行写, 需要用反斜杠“\”进行连接(有括号括起来的内容就不用)。 不同代码块之间要注意用冒号和缩进来区分代码块之间的层次关系,如:
for i in range(0,b3): if (iAnglelowfg[i]=='/'): for l in range(0,i-j-1): c3[k]=c3[k]+iAnglelowfg[j+l+1] j=i elif (iAnglelowfg[i]==']'):
优点:界面直观,简单易懂; 缺点:操作步骤繁琐,不利于修改,缺乏通用性。
➢ ②通过inp文件建模
优点:可以直接在ABAQUS中提交; 缺点:只包含模型节点信息,代码较多,修改不便;
Abaqus二次开发
Abaqus二次开发——Abaqus/python入门体会入门实例#===========================================================自己的论文要用到有限元进行数值模拟分析,以前都用ansys计算,可ansys中岩土的本构模型只有D-P模型,无法准确的反映土的硬化/软化性质,模拟计算出的结果因此也和实际差别很大。
Abaqus有着丰富的材料模型,超强的非线性分析能力,岩土的模型也很多,因此才转学Abaqus。
Abaqus的cae建模功能还是很好的,但科研课题一般都要进行参数分析,采用cae的建模方法有些不切实际,学了没几天就放弃cae开始学习inp,也是学了一阵子才知道inp不能建立实体模型,只能直接建节点和单元。
复杂的模型inp也无法建立,但采用Python建模就可以解决这个问题。
由于Abaqus的学习资料不多,过了好些日子才知道Abaqus也可以采用Python语言进行建模计算,只是比Ansys的Apdl语言复杂得多,并且除了手册上的Script资料之外,没有较为系统的教程,刚一接触真是让人头痛。
通过查看Simwe论坛上关于Python的帖子,和论坛朋友的帮助,自己在慢慢积累,现在对Python有了一点点了解,算是入了个门。
接触Abaqus也没多久,对python更是一知半解,绝大多数地方根本都不清楚,抽空写一点认识体会主要是给像自己一样刚学习Abqus Python的朋友,能少走一些弯路,节约一些时间。
同时希望大家批评指正、共同讨论、补充。
#--------------------------------------------------------------------------------------------------学习Abaqus/Python基础:Abaqus的cae建模有比较全面的认识;了解一些Python语法知识(大家都不会有太多时间单独学习Python语言本身,只需要有概念了解即可,不懂的地方可以随时查询Python script手册)Abaqus/Python学会使用不太难,可要精通应用还是要付出一定的劳动。
Python在ABAQUS二次开发中的应用实例2
;
不同数据类型之间可通过函数转换,如int()、float()。
可以用替代符号表示定制字符串,如
stress=1234.56 print ‘The stress is %f MPa’ % stress
即可输出: The stress is 1234.56 Mpa
符号 %c %s %d %u 描述 定制字符及其ASCII码 定制字符串 定制整数 定制无符号整数 符号 %o %x %f %e 描述 定制无符号八进制数 定制无符号十六进制数 定制浮点型数据 用科学计数法定义浮点型数据
编写脚本可以实现以下功能:
自动执行重复任务; 进行参数分析; 创建和修改模型;
访问输出数据库(ODB文件);
定制ABAQUS环境文件; 创建ABAQUS插件程序。
编写完成的脚本文件,可以直接在ABAQUS运行:
File → Run Script,打开相应的.py文件,即可执行; 刚打开ABAQUS界面,直接选择Run Script也可; 可以在GUI界面下部的命令行接口输入脚本语句执行。
打开方式
File → Abaqus PDE,然后打开相应的.py文件,即可编辑调试。
ABAQUS 脚本概述
调试ABAQUS脚本
点 点 点 点 点
按钮可以调试整个脚本文件; 按钮可以逐行调试脚本文件,调试行显示为蓝色; 按钮可以停止调试文件; 按钮可以设置断点,调试时将调到此行为止; 按钮,然后点 按钮,可以录制CAE中的操作,点 可以停止录制。
语句前加上 # 号,表示是注释内容,这个语句将不被执行; 使用中文注释,要在文件最开始加上:# -*- coding: UTF-8-*以换行来识别一个逻辑语句的结束。如果需要在一个物理行中编写多个逻辑语 句,需要用分号分开。如:x=1;y=2;z=3。如果一个逻辑语句太长需要分行写, 需要用反斜杠‚\‛进行连接(有括号括起来的内容就不用)。 不同代码块之间要注意用冒号和缩进来区分代码块之间的层次关系,如:
利用Python对Abaqus进行后处理结果输出
利用Python对Abaqus进行后处理结果输出-----中大_戚超_2016.10.31 概述在Abaqus的二次开发过程中,通常需要采用Python脚本语言将Abaqus的计算结果进行输出,然后再进行处理。
Python使Abaqus的内核语言,使用较为方便,Abaqus运行Python语言的方式有多种,可以直接命令窗口,也可以读入脚本,还可以采用类似批处理的方式。
本次以一个例子细说Python语言在Abaqus后处理中的应用,模型的计算结果云图如图1所示。
图1 计算结果2 输出所有积分点上的Mises应力直接上Python代码:import osfrom odbAccess import*from textRepr import*myodb=openOdb(path='Job-1.odb')cpFile=open('artlcF1.txt','w')RF=myodb.steps['Step-1'].frames[1].fieldOutputs['S'].valuesfor i in range(len(RF)) :cpFile.write('%.3F\n' %(RF[i].mises))else:cpFile.close()#引入模块,因为需要打开结果文件#打开结果文件,并复制给变量myodb#打开一个txt文件#将输出场赋值给RF#循环语句,向txt文件逐行写入mises应力Abaqus的结构层次分的很细,比如结果文件下分如下:使用过Abaqus的都知道step表示载荷步,frame表示载荷子步,因而在读取Mises应力时需要详细地指定输出哪一步的应力,而应力结果是输出场数据(fieldOutput)的中一种,需要指定是何种应力,程序才知道怎么读取并写入。
由于Abaqus里面涉及的变量特别多,通常很难记清楚那一项下面都有哪些量可以调用,此时比较好的方式是采用print 函数查看,例如查看myodb.steps['Step-1'].frames[1].fieldOutputs 下面有哪些变量可以调用,在窗口输入:print myodb.steps['Step-1'].frames[1].fieldOutputs显示:{'AC YIELD': 'FieldOutput object', 'CF': 'FieldOutput object', 'E': 'FieldOutput object', 'PE': 'Fiel dOutput object', 'PEEQ': 'FieldOutput object', 'PEMAG': 'FieldOutput object', 'RF': 'FieldOutput object', 'S': 'FieldOutput object', 'U': 'FieldOutput object'}各种不同的结果,包括位移、应力和支反力等等,因此可以知道通过如下的方式读取应力:myodb.steps['Step-1'].frames[1].fieldOutputs ['S']此时读取的信息特别多,我们想要的是其中的数值信息,因此可以:myodb.steps['Step-1'].frames[1].fieldOutputs ['S'].values通过此句能够读取所有节点的应力数据,输出其中一个:print myodb.steps['Step-1'].frames[1].fieldOutputs ['S'].values[0]显示:({'baseElementType': 'C3D8R', 'conjugateData': None, 'conjugateDataDouble': 'unknown', 'da ta': array([-855397.25, 58.817497253418, 358.723419189453, -139.652938842773, -456.986175537109, 4.29301929473877], 'f'), 'dataDouble': 'unknown', 'elementLabel': 1, 'fac e': None, 'instance': 'OdbInstance object', 'integrationPoint': 1, 'inv3': -855606.3125, 'localCoordSystem': None, 'localCoordSystemDouble': 'unknown', 'magnitude': None, 'maxInPlanePrincipal': 0.0, 'maxPrincipal': 359.0310********, 'midPrincipal': 58.7767 486572266, 'minInPlanePrincipal': 0.0, 'minPrincipal': -855397.5, 'mises': 855606.375, 'nodeLabel': None, 'outOfPlanePrincipal': 0.0, 'position': INTE GRATION_POINT, 'precision': SINGLE_PRECISION, 'press': 284993.25, 'sectionPoint': None, 'tr esca': 855756.5, 'type': TENSOR_3D_FULL})输出的信息特别多,但是可以看到有mises这一项。
abaqus-python二次开发方法
abaqus-python二次开发方法(超实用)基于的二次开发对于很多新手来说都是一个神秘的,感觉是高难度的问题,致使很多新手对二次开发的研究都处于初级了解阶段,或完全不感冒阶段。
其实二次开发很简单,某种意义上讲,常用的ABAQUS二次开发方式有两种,(1)直接修改inp文件,这种方式需要对inp文件中大量的节点和单元进行操作,一般不建议采用inp文件进行二次开发(除非有特殊的关键字或标识符,其实关键字也可以用python语言来进行二次开发,笔者亲证)。
采用inp文件进行二次开发数据量大,行数多,一旦发生问题难以检测错误原因(2)采用abaqus语言,自编脚本,简单容易,非常适合初学者。
这里主要介绍python入门python语言的开发远没有想象中的难,其实基于abaqus语言的二次开发更像是word或excel里的VBA,我们只要通过录制一段宏文件,就可以简单迅速的完成一个模型的建立,当我们人为的对这段宏文件进行修改,就可以完成对该模型的修改,非常适合有大量相同或类似模型的建立,防止用户一遍又一遍繁琐的建模操作。
简单的步骤如下:1.在建模前先打开file--Macro Manager,然后新建一个宏文件(在Home或Work都行,只要你最终能找到这个文件),此时会弹出Record Macro对话框,托至不碍事的地方2.进行正常的cae建模就行,至到建模完成3.点击Record Macro对话框的Stop Mecording,此时命令栏会显示“Macro "Macroname" has been added to "E:\Temp\Macroname.py"”,前期任务搞定4.此时用文本编辑器打开此py文件,py文件中有些文字是没有用的,把“def Macro1 ...import connectorBehavior”都可以删掉,每行字前的空格都要去掉(文本编辑器里一般有列模式,用列模式可以对整个文本的进行操作)5.复制你新生成的python文件,并对该文件中的参数进行修改,在提交给abaqus--cae就可以完成重复建模了,如此可以无限重复,其实python语言都是大白话,你能看懂的需要指出的是:1.可以结合其它编程语言如VB、VC 配合修改参数并生成py文件,使用更为灵活2.生成py文件可以直接在cae中选择file-run script,选择你生成的python文件3.可以用python文件直接生成cae模型文件,可在py文件最后添加"mdb.saveAs(pathName='" *** "')"4.可以通过cmd命令直接将py文件提交个abaqus内核,让abaqus进行运算,cmd命令为“Shell"C:\Windows\SysWOW64\cmd.exe /k abaqus cae noGUI=" **** ".py ", vbHide等待abaqus运算的py语言"myJob.submit(consistencyChecking=OFF, datacheckJob=True)"。
Python语言在ABAQUS中的应用
Python语言在ABAQUS中的应用采用python脚本语言二次开发ABAQUS,通过开发python脚本程序处理ABAQUS重复工作,提高了工作效率。
标签Python;ABAQUS;交换输入;函数引言ABAQUS是大型通用的有限元分析软件,可以模拟绝大部分工程材料的线性和非线性行为,获得了广大用户的认可,在建筑结构分析领域应用广泛。
Python是一种面向对象的脚本语言,,该语言已经诞生20余年,它的简洁性和易用性使程序的开发过程变得简单,特别适用于快速应用开发。
在此介绍一下编写脚本快速建模。
编写Python脚本快速建立模型是ABAQUS高级用户经常使用的功能之一。
例如,在Abaqus/CAE中建模时需要反复输入各种参数和设置多个对话框,编写脚本只需要几条语句就可以实现。
如果经常建立相同或类似模型,还可以编写独立的模块,还可以编写脚本创建材料库,运行Python脚本后Material Manager 将自动出现定义的材料。
在此介绍3种最常用的快速建立模型的方法,包括交互式输入、创建材料库。
1.交互式输入交互式输入直接指定模型参数,而无需在Abaqus/CAE下选择多个菜单、多个按钮,可以节省许多建模时间。
Abaqus脚本接口提供3种交互式输入函数,分别是:getInput()函数、getInputs()函数和getWarningReply ()函数,详细介绍参见Abaqus 6.10帮助手册《Abaqus Scripting User’s Manual》第6.7节“Prompting the user for input”和<《Abaqus Scripting Reference Manual》第49.5节“User input commands”。
GetInput()函数脚本getInput.py将调用getInput()函数自定义输入参数,开平方根运算后输出计算结果。
程序测试代码如下:from abaqus import *from math import sqrtinput=getInput(’please enter a number ‘,’9’)number=float(input)print sqrt(number)GetInputs()函数脚本getInputs.py将调用getInputs()函数自定义输入并输出数据信息,代码如下:from abaqus import *x=getInputs(((’please enter the first number ‘,’2’),(’please enter the second number’,’5’),(’please enter the third number’,’8’)))print xGetWarningReply ()函数脚本getWarningReply.py将调用get Warning Reply ()函数来创建警告对话框。
Python语言和ABAQUS后处理二次开发定稿
Python语言和ABAQUS后处理二次开发1易桂莲杜家政隋允康2(北京工业大学机械工程与应用电子技术学院,100124北京)摘要:采用Python脚本语言二次开发ABAQUS的后处理模块,讨论了ABAQUS的脚本接口和对象模型在二次开发中的作用和调用流程。
通过开发Python脚本程序提取ABAQUS进行数值模拟后的计算结果,有效地解决了提取大量结果进行重复操作的问题,提高了后处理的效率。
关键词:ABAQUS后处理二次开发;Python;动力响应分析;振动特性0 引言ABAQUS是国际上最先进的大型通用有限元计算分析软件之一,可以模拟绝大部分工程材料的线性和非线性行为。
ABAQUS自带的CAE是进行有限元分析的前后处理模块,也是建模、分析和后处理的人机交互平台,它具有良好的人机对话界面,因此ABAQUS软件在工程中得到了广泛的应用。
Python是一种面向对象的脚本语言,它功能强大,既可以独立运行,也可以用作脚本语言。
特别适用于快速的应用程序开发[1]。
通过开发Python脚本程序提取ABAQUS进行数值模拟后的计算结果,有效地解决了提取大量结果进行重复操作的问题1 二次开发接口介绍ABAQUS 脚本接口是一个基于对象的程序库,脚本接口中的每个对象都拥有相应的数据成员和函数。
对象的函数专门用于处理对象中的数据成员,被称为相应对象的方法,用于生成对象的方法被称为构造函数。
在对象创建后,可以使用该对象提供的方法来处理对象中的数据成员[2]。
ABAQUS提供了一套应用程序编程接口(API,Application Program Interface)来操作ABAQUS/CAE实现建模/后处理等功能。
接口编程采用Python的语法编写脚本,但扩展了Python脚本语言,额外提供了大约500个对象模型。
对象模型之间关系复杂,图1展示了这些对象模型之间的层次结构和相互关系。
其中,Container表示容器,里面包含有其他的对象;Singular object表示单个对象。
基于Python的Abaqus二次开发实例讲解
基于Python的Abaqus二次开发实例讲解(asian58 2013.6.26)基于Python的Abaqus的二次开发便捷之处在于:1、所有的代码均可以先在Abaqus\CAE中操作一遍后再通过rp文件读取,然后再在此基础上进行相应的修改;2、Python是一种解释性语言,读起来非常清晰,因此在修改程序的过程中,不存在程序难以理解的问题;3、Python是一种通用性的、功能非常强大的面向对象编程语言,有许多成熟的类似于Matlab函数的程序在网络上流传,为后期进一步的数据处理提供了方便。
为了更加方便地完成Abaqus的二次开发,需进行一些相关约定:1、所有参数化直接通过点的坐标值进行,直接对几何尺寸的参数化反而更加繁琐;2、程序参数化已不允许在模型中添加太多的Tie,因此不同零部件的绑定直接通过共节点来进行,这就要求建模方法与常规的建模方法有所区别。
思路如下:将一个整机拆成几个大的Part来建立,一个Part中包含许多零件,这样在划分网格式时就可以自动实现共节点的绑定。
不同的零件可通过建立不同的Set来进行区分,不同Part 的绑定可以通过Tie来实现。
将一个复杂的结构拆成几个恰当的Part来建立,一方面可以将复杂的模型简单化,使建立复杂模型成为可能;另一方面,不同的Part可单独调用,从而又可实现程序的模块化,增加程序的适应范围,延长程序的使用寿命,也方便后期程序的维护和修改。
3、通过py文件建立起的模型要进行参数优化,已不适合采用Isight中Abaqus模块,需要用到Isight的Simcode模块。
下面详细解释一个臂架的py文件。
#此程序用来绘制臂架前段#导入相关模块# -*- coding: mbcs -*-from abaqus import *from abaqusConstants import *#定义整个臂架的长、宽、高L0=14300W0=1650H0=800#创建零件P01_12 L1=H0+200 W1=200 T1=12s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__', sheetSize=2000.0)g, v, d, c = s.geometry, s.vertices, s.dimensions, s.constraints s.setPrimaryObject(option=STANDALONE)s.rectangle(point1=(W0/2, L1/2), point2=(W0/2+W1, -L1/2))s.rectangle(point1=(-W0/2, L1/2), point2=(-W0/2-W1, -L1/2))p = mdb.models['Model-1'].Part(name='Part-1', dimensionality=THREE_D, type=DEFORMABLE_BODY)p = mdb.models['Model-1'].parts['Part-1'] p.BaseShell(sketch=s)session.viewports['Viewport: 1'].setValues(displayedObject=p) del mdb.models['Model-1'].sketches['__profile__']#定义零件的厚度p = mdb.models['Model-1'].parts['Part-1'] f = p.faces pickedFaces01 = f.findAt (((W0/2, L1/2, 0),),((-W0/2, L1/2, 0),), ) p.assignThickness(faces=pickedFaces01, thickness=T1) p.Set(faces=pickedFaces01, name='P01_12')#创建辅助平面和辅助坐标系p = mdb.models['Model-1'].parts['Part-1']p.DatumCsysByThreePoints(name='Datum csys-1', coordSysType=CARTESIAN, origin=( 0.0, 0.0, 0.0), line1=(1.0, 0.0, 0.0), line2=(0.0, 1.0, 0.0))p = mdb.models['Model-1'].parts['Part-1']p.DatumPlaneByPrincipalPlane(principalPlane=XYPLANE, offset=L0)#创建零件P02_12 L2=L1 W2=W1 T2=12p = mdb.models['Model-1'].parts['Part-1'] d = p.datums#将草图原点参数化t = p.MakeSketchTransform(sketchPlane=d[5], sketchUpEdge=d[4].axis2, sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, origin=(0.0, 0.0, L0)) s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__', sheetSize=29006.85, gridSpacing=725.17, transform=t) g, v, d1, c = s.geometry, s.vertices, s.dimensions, s.constraints s.setPrimaryObject(option=SUPERIMPOSE)p = mdb.models['Model-1'].parts['Part-1']s.rectangle(point1=(W0/2, L2/2), point2=(W0/2+W2, -L2/2))s.rectangle(point1=(-W0/2, L2/2), point2=(-W0/2-W2, -L2/2))p = mdb.models['Model-1'].parts['Part-1']d2 = p.datumsp.Shell(sketchPlane=d2[5], sketchUpEdge=d2[4].axis2, sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, sketch=s)s.unsetPrimaryObject()del mdb.models['Model-1'].sketches['__profile__']#定义零件的厚度p = mdb.models['Model-1'].parts['Part-1'] Array f = p.facespickedFaces02 = f.findAt(((W0/2, L1/2, L0),),((-W0/2, L1/2, L0),), )p.assignThickness(faces=pickedFaces02, thickness=T2)p.Set(faces=pickedFaces02, name='P02_12')#创建零件P03_12和零件P04_08T3=12T4=8p = mdb.models['Model-1'].parts['Part-1']d = p.datumst = p.MakeSketchTransform(sketchPlane=d[5], sketchUpEdge=d[4].axis2, sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, origin=(0.0, 0.0, L0)) s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__', sheetSize=29006.85, gridSpacing=725.17, transform=t)g, v, d1, c = s.geometry, s.vertices, s.dimensions, s.constraintss.setPrimaryObject(option=SUPERIMPOSE)#创建草图p = mdb.models['Model-1'].parts['Part-1']s.Line(point1=(-W0/2-W1, H0/2), point2=(-W0/2, H0/2))s.Line(point1=(W0/2, H0/2), point2=(W0/2+W1, H0/2))s.Line(point1=(-W0/2-W1, -H0/2), point2=(-W0/2, -H0/2))s.Line(point1=(W0/2, -H0/2), point2=(W0/2+W1, -H0/2))p = mdb.models['Model-1'].parts['Part-1']d2 = p.datumsp.ShellExtrude(sketchPlane=d2[5], sketchUpEdge=d2[4].axis2,sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, sketch=s, depth=L0, flipExtrudeDirection=ON)s.unsetPrimaryObject()del mdb.models['Model-1'].sketches['__profile__']#定义零件P03_12的厚度p = mdb.models['Model-1'].parts['Part-1']f = p.facespickedFaces03 = f.findAt(((-W0/2, H0/2, L0/2),),((W0/2, H0/2, L0/2),),)p.assignThickness(faces=pickedFaces03, thickness=T3)p.Set(faces=pickedFaces03, name='P03_12')#定义零件P04_12的厚度p = mdb.models['Model-1'].parts['Part-1']f = p.facespickedFaces04 = f.findAt(((-W0/2, -H0/2, L0/2),),((W0/2, -H0/2, L0/2),),)p.assignThickness(faces=pickedFaces04, thickness=T4)p.Set(faces=pickedFaces04, name='P04_12')#创建零件P05_08T5=8p = mdb.models['Model-1'].parts['Part-1']d = p.datumst = p.MakeSketchTransform(sketchPlane=d[5], sketchUpEdge=d[4].axis2, sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, origin=(0.0, 0.0, L0))s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__',sheetSize=29006.85, gridSpacing=725.17, transform=t)g, v, d1, c = s.geometry, s.vertices, s.dimensions, s.constraintss.setPrimaryObject(option=SUPERIMPOSE)p = mdb.models['Model-1'].parts['Part-1']s.Line(point1=(-W0/2-W1/2, H0/2), point2=(-W0/2-W1/2, -H0/2))s.Line(point1=(W0/2+W1/2, H0/2), point2=(W0/2+W1/2, -H0/2))p = mdb.models['Model-1'].parts['Part-1']d2 = p.datumsp.ShellExtrude(sketchPlane=d2[5], sketchUpEdge=d2[4].axis2,sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, sketch=s, depth=L0,flipExtrudeDirection=ON)s.unsetPrimaryObject()del mdb.models['Model-1'].sketches['__profile__']#定义零件P05_8的厚度p = mdb.models['Model-1'].parts['Part-1']f = p.facespickedFaces05 = f.findAt(((-W0/2-W1/2, 0, L0/2),),((W0/2+W1/2, 0, L0/2),),)p.assignThickness(faces=pickedFaces05, thickness=T5)p.Set(faces=pickedFaces05, name='P05_08')#创建零件P06_08L6=W0+W1n=L0//2520+1T6=8p = mdb.models['Model-1'].parts['Part-1']f, d = p.faces, p.datumst = p.MakeSketchTransform(sketchPlane=f[0], sketchUpEdge=d[4].axis2, sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, origin=(W0/2+W1/2, -H0/2,0))s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__',sheetSize=28684, gridSpacing=717, transform=t)g, v, d1, c = s.geometry, s.vertices, s.dimensions, s.constraintss.setPrimaryObject(option=SUPERIMPOSE)p = mdb.models['Model-1'].parts['Part-1']#循环命令绘制平行隔板for i in range(0,n): Array s.Line(point1=(-500-(i*2520), H0), point2=(-500-(i*2520), 0.0))p = mdb.models['Model-1'].parts['Part-1']f1, d2 = p.faces, p.datumsp.ShellExtrude(sketchPlane=f1[0], sketchUpEdge=d2[4].axis2,sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, sketch=s, depth=L6,flipExtrudeDirection=ON)s.unsetPrimaryObject()del mdb.models['Model-1'].sketches['__profile__']#定义零件P06_08的厚度p = mdb.models['Model-1'].parts['Part-1']f = p.facesfor i in range(0,n): Array pickedFaces = f.findAt(((0, H0/4, 500+i*2520),))p.assignThickness(faces=pickedFaces, thickness=T6)p.Set(faces=pickedFaces, name='P06_08_'+str(1+i))#创建零件P07_12,P08_12W7=200L7=W0+W1T7=12T8=12p = mdb.models['Model-1'].parts['Part-1']f, e = p.faces, p.edgest = p.MakeSketchTransform(sketchPlane=f.findAt(coordinates=(W0/2+W1/2, 0.0, 100.0)),sketchUpEdge=e.findAt(coordinates=(W0/2+W1/2, 0.0, 0.0)),sketchOrientation=RIGHT,sketchPlaneSide=SIDE1,origin=(W0/2+W1/2, -H0/2, 0.0))s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__',sheetSize=53678, gridSpacing=1341, transform=t)g, v, d, c = s.geometry, s.vertices, s.dimensions, s.constraintss.setPrimaryObject(option=SUPERIMPOSE)p = mdb.models['Model-1'].parts['Part-1']#循环命令绘制平行隔板for i in range(0,n):s.Line(point1=(400+i*2520, -H0), point2=(600+i*2520, -H0))s.Line(point1=(400+i*2520, 0), point2=(600+i*2520, 0))p = mdb.models['Model-1'].parts['Part-1']f1, e1 = p.faces, p.edgesp.ShellExtrude(sketchPlane=f.findAt(coordinates=(W0/2+W1/2, 0.0, 100.0)),sketchUpEdge=e.findAt(coordinates=(W0/2+W1/2, 0.0, 0.0)),sketchPlaneSide=SIDE1,sketchOrientation=RIGHT, sketch=s, depth=W0+W1, flipExtrudeDirection=ON, keepInternalBoundaries=ON)s.unsetPrimaryObject()del mdb.models['Model-1'].sketches['__profile__']#定义零件P07_12的厚度p = mdb.models['Model-1'].parts['Part-1']f = p.facesfor i in range(0,n):pickedFaces07 = f.findAt(((0, H0/2, 400+i*2520),),((0, H0/2, 600+i*2520),),) p.assignThickness(faces=pickedFaces07, thickness=T7)p.Set(faces=pickedFaces07, name='P07_12_'+str(1+i))fp=[]for i in range(0,2):fp.append(f.findAt(((0, H0/2, 400+i*2520),),((0, H0/2, 600+i*2520),),))p.Set(faces=fp, name='P07_fp')#定义零件P08_12的厚度p = mdb.models['Model-1'].parts['Part-1']f = p.facesfor i in range(0,n):pickedFaces08 = f.findAt(((0, -H0/2, 400+i*2520),),((0, -H0/2, 600+i*2520),),) p.assignThickness(faces=pickedFaces08, thickness=T7)p.Set(faces=pickedFaces08, name='P08_12_'+str(1+i))#为中间隔板创建空腔#定义相关参数边界距离、圆角d0=100r0=100p = mdb.models['Model-1'].parts['Part-1']f1, e1 = p.faces, p.edgest = p.MakeSketchTransform(f.findAt(coordinates=(0, 0.0, 500.0)),sketchUpEdge=e.findAt(coordinates=(W0/2+W1/2, 0.0, 500.0)),sketchPlaneSide=SIDE1, sketchOrientation=RIGHT,origin=(0.0, 0.0, 500.0))s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__',sheetSize=5910.0, gridSpacing=147.0, transform=t)g, v, d1, c = s.geometry, s.vertices, s.dimensions, s.constraintss.setPrimaryObject(option=SUPERIMPOSE)p = mdb.models['Model-1'].parts['Part-1']p.projectReferencesOntoSketch(sketch=s, filter=COPLANAR_EDGES)#创建矩形s.rectangle(point1=(-W0/2-W1/2+d0, H0/2-d0), point2=(W0/2+W1/2-d0, -H0/2+d0)) #创建圆角s.FilletByRadius(radius=r0,curve1=g[29], nearPoint1=(-W0/2-W1/2+d0, H0/2-d0), curve2=g[26], nearPoint2=(-W0/2-W1/2+d0, H0/2-d0))s.FilletByRadius(radius=r0, curve1=g[26], nearPoint1=(-W0/2-W1/2+d0, -H0/2+d0), curve2=g[27], nearPoint2=(-W0/2-W1/2+d0, -H0/2+d0)) s.FilletByRadius(radius=r0, curve1=g[27], nearPoint1=(W0/2+W1/2-d0, -H0/2+d0), curve2=g[28], nearPoint2=(W0/2+W1/2-d0, -H0/2+d0)) s.FilletByRadius(radius=r0, curve1=g[28], nearPoint1=(W0/2+W1/2-d0, H0/2-d0), curve2=g[29], nearPoint2=(W0/2+W1/2-d0, H0/2-d0))p = mdb.models['Model-1'].parts['Part-1']f1, d2 = p.faces, p.datumsp.CutExtrude(f.findAt(coordinates=(0, 0.0, 500.0)),sketchUpEdge=e.findAt(coordinates=(W0/2+W1/2, 0.0, 500.0)),sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, sketch=s, depth=L0, flipExtrudeDirection=OFF)s.unsetPrimaryObject()del mdb.models['Model-1'].sketches['__profile__']#开始建立梁Beam_1p = mdb.models['Model-1'].parts['Part-1']f, d = p.faces, p.datums#绘制参考面p.DatumPlaneByOffset(plane=f.findAt(coordinates=(W0/2, -H0/2, 100.0)),flip=SIDE2, offset=8.0)dp1 = d.keys()[-1]p = mdb.models['Model-1'].parts['Part-1']d = p.datumst = p.MakeSketchTransform(sketchPlane=d[dp1], sketchUpEdge=d[4].axis1,sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, origin=(0.0, 0.0,0.0))s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__', sheetSize=31857.0, gridSpacing=796.0, transform=t)g, v, d1, c = s.geometry, s.vertices, s.dimensions, s.constraintss.setPrimaryObject(option=SUPERIMPOSE)p = mdb.models['Model-1'].parts['Part-1']#计算中间加强梁的数量if n%2==1:n1=n//2 n2=n//2 else:n1=n//2 n2=n//2-1 for i in range(0,n1):s.Line(point1=(-500-i*2520*2, W0/2+W1/2), point2=(-500-2520-i*2520*2,-W0/2-W1/2 )) for i in range(0,n2):s.Line(point1=(-500-2520-i*2520*2,-W0/2-W1/2), point2=(-500-2*2520-i*2520*2,W0/2+W1/2 ))#在基准平面dp1上面绘制梁p = mdb.models['Model-1'].parts['Part-1'] d2 = p.datums e = p.edgesp.Wire(sketchPlane=d2[dp1], sketchUpEdge=d2[4].axis1, sketchPlaneSide=SIDE1, sketchOrientation=RIGHT, sketch=s) s.unsetPrimaryObject()del mdb.models['Model-1'].sketches['__profile__'] edges1=[] for i in range(0,n-1): edges1.append (e.findAt(((0, -H0/2-8, 500+2520/2+i*2520),),)) p.Set(edges=edges1, name='Beam_1') ############################开始定义有限元分析的相关参数 #定义材料mdb.models['Model-1'].Material(name='steel')mdb.models['Model-1'].materials['steel'].Elastic(table=((210000.0, 0.3), )) mdb.models['Model-1'].materials['steel'].Density(table=((7.8e-06, ), ))#定义壳单元属性mdb.models['Model-1'].HomogeneousShellSection(name='shell', preIntegrate=OFF, material='steel', thicknessType=UNIFORM, thickness=10.0, thicknessField='', idealization=NO_IDEALIZATION, poissonDefinition=DEFAULT,thicknessModulus=None, temperature=GRADIENT, useDensity=OFF, integrationRule=SIMPSON, numIntPts=5) #赋所有壳单元属性p = mdb.models['Model-1'].parts['Part-1']for i in range(1,5):region1 = p.sets['P0'+str(i)+'_12']p.SectionAssignment(region=region1, sectionName='shell', offset=0.0,offsetType=FROM_GEOMETRY , offsetField='',thicknessAssignment=FROM_GEOMETRY )region2 = p.sets['P05_08']p.SectionAssignment(region=region2, sectionName='shell', offset=0.0, offsetType=FROM_GEOMETRY, offsetField='',thicknessAssignment=FROM_GEOMETRY)for i in range(1,n+1): Array region3 = p.sets['P06_08_'+str(i)]p.SectionAssignment(region=region3, sectionName='shell', offset=0.0,offsetType=FROM_GEOMETRY, offsetField='',thicknessAssignment=FROM_GEOMETRY)for i in range(1,n+1):region4 = p.sets['P07_12_'+str(i)]p.SectionAssignment(region=region4, sectionName='shell', offset=0.0,offsetType=FROM_GEOMETRY, offsetField='',thicknessAssignment=FROM_GEOMETRY)for i in range(1,n+1):region5 = p.sets['P08_12_'+str(i)]p.SectionAssignment(region=region5, sectionName='shell', offset=0.0,offsetType=FROM_GEOMETRY, offsetField='',thicknessAssignment=FROM_GEOMETRY)#定义梁单元属性mdb.models['Model-1'].LProfile(name='L_65', a=65.0, b=65.0, t1=7.0, t2=7.0)mdb.models['Model-1'].BeamSection(name='B_65', integration=DURING_ANALYSIS,poissonRatio=0.0, profile='L_65', material='steel', temperatureVar=LINEAR,consistentMassMatrix=False)#赋所有梁单元属性p = mdb.models['Model-1'].parts['Part-1']region = p.sets['Beam_1']p.SectionAssignment(region=region, sectionName='B_65', offset=0.0,offsetType=MIDDLE_SURFACE, offsetField='',thicknessAssignment=FROM_SECTION)p.assignBeamSectionOrientation(region=region, method=N1_COSINES, n1=(0.0, 0.0,-1.0))#定义装配体import assemblya = mdb.models['Model-1'].rootAssemblya.DatumCsysByDefault(CARTESIAN)p = mdb.models['Model-1'].parts['Part-1']a.Instance(name='Part-1-1', part=p, dependent=ON)#定义分析步import stepmdb.models['Model-1'].StaticStep(name='Step-1', previous='Initial')#定义底面与梁的tiedimport interactiona = mdb.models['Model-1'].rootAssemblyregion1=a.instances['Part-1-1'].sets['P04_12']region2=a.instances['Part-1-1'].sets['Beam_1']mdb.models['Model-1'].Tie(name='Constraint-1', master=region1, slave=region2, positionToleranceMethod=COMPUTED, adjust=OFF, tieRotations=ON, thickness=ON)#开始定义耦合#导入相关模块import regionToolseta = mdb.models['Model-1'].rootAssemblyd, r = a.datums, a.referencePoints#定义参考点a.ReferencePoint(point=(0.0, H0/2, 500+2520/2))rp1 = r.keys()[-1]refPoints1=(r1[rp1], )region1=regionToolset.Region(referencePoints=refPoints1)s1 = a.instances['Part-1-1'].facesregion2 = a.instances['Part-1-1'].sets['P07_fp']mdb.models['Model-1'].Coupling(name='Constraint-2', controlPoint=region1, surface=region2, influenceRadius=WHOLE_SURFACE, couplingType=DISTRIBUTING, localCsys=None, u1=ON, u2=ON, u3=ON, ur1=ON, ur2=ON, ur3=ON)#########################定义边界条件import loada = mdb.models['Model-1'].rootAssemblyd, r = a.datums, a.referencePointsregion = a.instances['Part-1-1'].sets['P02_12']mdb.models['Model-1'].DisplacementBC(name='SPC', createStepName='Initial', region=region, u1=SET, u2=SET, u3=SET, ur1=SET, ur2=SET, ur3=SET,amplitude=UNSET, distributionType=UNIFORM, fieldName='', localCsys=None)a = mdb.models['Model-1'].rootAssemblyregion = a.instances['Part-1-1'].sets['P08_12_'+str(n-1)]mdb.models['Model-1'].DisplacementBC(name='SPC2', createStepName='Initial', region=region, u1=SET, u2=SET, u3=SET, ur1=SET, ur2=SET, ur3=SET,amplitude=UNSET, distributionType=UNIFORM, fieldName='', localCsys=None)r1 = a.referencePointsrefPoints1=(r1[rp1], )region = regionToolset.Region(referencePoints=refPoints1)mdb.models['Model-1'].ConcentratedForce(name='force', createStepName='Step-1',region=region, cf2=-10000.0, distributionType=UNIFORM, field='',localCsys=None)mdb.models['Model-1'].Gravity(name='G', createStepName='Step-1', comp2=-9.8, distributionType=UNIFORM, field='')#################划分网格import meshp = mdb.models['Model-1'].parts['Part-1']p.seedPart(size=20.0, deviationFactor=0.1, minSizeFactor=0.1)p.generateMesh()a = mdb.models['Model-1'].rootAssembly###############创建作业并提交分析import jobmdb.Job(name='006', model='Model-1', description='', type=ANALYSIS, atTime=None, waitMinutes=0, waitHours=0, queue=None, memory=90,memoryUnits=PERCENTAGE, getMemoryFromAnalysis=True,explicitPrecision=SINGLE, nodalOutputPrecision=SINGLE, echoPrint=OFF,modelPrint=OFF, contactPrint=OFF, historyPrint=OFF, userSubroutine='',scratch='', multiprocessingMode=DEFAULT, numCpus=4, numDomains=4) mdb.jobs['006'].submit(consistencyChecking=ON)mdb.jobs['006'].waitForCompletion()###############进入后处理模块import visualizationo3 = session.openOdb(name='F:/ABAQUS/006.odb')session.viewports['Viewport: 1'].setValues(displayedObject=o3)session.viewports['Viewport: 1'].odbDisplay.display.setValues(plotState=( CONTOURS_ON_DEF, ))session.viewports['Viewport: 1'].view.setValues(session.views['Iso'])mdb.saveAs(pathName='F:/ABAQUS/006.cae')第11 页共11 页。
ABAQUS二次开发教程
ABAQUS二次开发教程ABAQUS(Python语言)二次开发人生苦短,我用Python作者:Fan Shengbao2017年12月目录Python程序基本语法1.1Python语法结构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=11x2=2 2x2=41x3=3 2x3=6 3x3=91x4=4 2x4=8 3x4=12 4x4=161x5=5 2x5=10 3x5=15 4x5=20 5x5=251x6=6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=361x7=7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=491x8=8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=641x9=9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=638x9=72 9x9=81Python程序中一行中“#”号后面的内容为注释,“#”号只支持单行注释,多行注释可使用“’’’ …‘’’”注释符。
'''Python'''1.2P ython元组Python中的元组(tuple)相当于C语言中的数组简化版,其内容和长度均不可变,只能对其内容进行访问。
使用python进行ABAQUS的二次开发的简要说明(byYoung2017.06.27)
使用python进行ABAQUS的二次开发的简要说明(byYoung2017.06.27)(所有用词以英文为准,翻译仅供参考)一、abaqus二次开发总述:首先最重要的知识点需要明确,abaqus在求解核心(Solver/ Kernel)和图形用户界面(GUI)之间使用的交互语言天然就是python,因此使用python进行abaqus二次开发是十分自然的选择(当然你也可以用C++,但是鉴于python所拥有的各类开源库函数的优势,python应当是二次开发的首选)。
abaqus已经使用python 写好了很多用于计算、建模、GUI等操作的模块,因此二次开发的重点在于灵活调用这些模块,完成自己的设计计算需求。
所以原则上,所有能通过abaqus/CAE交互完成的操作,使用脚本都可以实现。
并且由于Python提供的丰富的函数资源库,会使得很多复杂的建模的过程更加参数化,更加可控,有时候甚至更加简单。
其次二次开发的学习要点在于勤查手册,其中Abaqus Scripting User's Manual和Abaqus Scripting User's Reference Manual是查阅的重点,其中后者是abaqus中各个object内置方法,路径,输入参数等的详细说明。
最后关于调用脚本的几种用法说明:(1)直接在命令行调用调用脚本并打开cae界面: abaqus cae script=myscript.py调用用于可视化操作脚本,打开显示界面(注意:此时只有visualization模块被激活): abaqus cae viewer=myscript.py 调用脚本在命令行执行,同时不打开GUI界面,但会进入python 交互界面:abaqus cae noGUI=myscript.py(2)在abaqus的GUI界面调用按照Main Menu: File->Run Script,选择需要调用的脚本文件,abaqus会进行执行(3)在abaqus的命令行交互界面调用(command line interface,在abaqus的GUI界面打开之后,窗口的最下方会有命令输入的位置,在这里也可以调用python脚本,执行方法是键入命令:execfile('myscript.py')abaqus的python脚本其实和其他应用场景下的python脚本没有太多区别,只不过有很多abaqus已经开发好的对象库可供使用,其学习过程和学习任何其他python库都是一致的。
在abaqus中利用python语言建模例子
3.1 Creating a partThe first example shows how you can use an Abaqus/CAE script to replicate the functionality of Abaqus/CAE. The script does the following:∙Creates a new model in the model database.∙Creates a two-dimensional sketch.∙Creates a three-dimensional, deformable part.∙Extrudes the two-dimensional sketch to create the first geometric feature of the part.∙Creates a new viewport.∙Displays a shaded image of the new part in the new viewport. The new viewport and the shaded part are shown in Figure 3–1. Figure 3–1 The example creates a new viewport and a part.The example scripts from this manual can be copied to the user's working directory by using the Abaqus fetch utility:abaqus fetch job=scriptNamewhere scriptName.py is the name of the script (see “Execution procedure for fetching sample input files,” Section 3.2.12 of the Abaqus Analysis User's Manual). Use the following command to retrieve the script for this example:abaqus fetch job=modelAExampleNote: Abaqus does not install the sample scripts by default during the installation procedure. As a result, if the Abaqus fetch utility fails to find the sample script, the script may be missing from your Abaqus installation. You must rerun the installation procedure and request Abaqus sample problems from the list of items to install.To run the program, do the following:1.Start Abaqus/CAE by typing abaqus cae.2.From the startup screen, select Run Script.3.From the Run Script dialog box that appears, selectmodelAExample.py.4.Click OK to run the script.Note: If Abaqus/CAE is already running, you can run the script by selecting File Run Script from the main menu bar.3.1.1 The example script"""modelAExample.pyA simple example: Creating a part."""from abaqus import *import testUtilstestUtils.setBackwardCompatibility()from abaqusConstants import *import sketchimport partmyModel = mdb.Model(name='Model A')mySketch = myModel.ConstrainedSketch(name='Sketch A', sheetSize=200.0)xyCoordsInner = ((-5 , 20), (5, 20), (15, 0),(-15, 0), (-5, 20))xyCoordsOuter = ((-10, 30), (10, 30), (40, -30),(30, -30), (20, -10), (-20, -10),(-30, -30), (-40, -30), (-10, 30))for i in range(len(xyCoordsInner)-1):mySketch.Line(point1=xyCoordsInner[i],point2=xyCoordsInner[i+1])for i in range(len(xyCoordsOuter)-1):mySketch.Line(point1=xyCoordsOuter[i],point2=xyCoordsOuter[i+1])myPart = myModel.Part(name='Part A', dimensionality=THREE_D,type=DEFORMABLE_BODY)myPart.BaseSolidExtrude(sketch=mySketch, depth=20.0)myViewport = session.Viewport(name='Viewport for Model A',origin=(10, 10), width=150, height=100)myViewport.setValues(displayedObject=myPart)myViewport.partDisplay.setValues(renderStyle=SHADED)3.1.2 How does the script work?This section explains each portion of the example script.from abaqus import *This statement makes the basic Abaqus objects accessible to the script. It also provides access to a default model database using the variable named mdb. The statement, from abaqusConstants import *, makes the Symbolic Constants defined by the Abaqus Scripting Interface available to the script.import sketchimport partThese statements provide access to the objects related to sketches and parts. sketch and part are called Python modules.The next statement in the script is shown in Figure 3–2. You can read this statement from right to left as follows:1.Create a new model named Model A.2.Store the new model in the model database mdb.3.Assign the new model to a variable called myModel.Figure 3–2 Creating a new model.mySketch = myModel.ConstrainedSketch(name='Sketch A', sheetSize=200.0) This statement creates a new sketch object named Sketch A in myModel. The variable mySketch is assigned to the new sketch. The sketch will be placed on a sheet 200 units square. Note the following:∙ A command that creates something (an “object” in object-oriented programming terms) is called a constructor and starts with anuppercase character. You have seen the Model and Sketch commands that create Model objects and Sketch objects, respectively.∙The command uses the variable myModel that we created in the previous statement. Using variables with meaningful names in ascript makes the script easier to read and understand.xyCoordsInner = ((-5 , 20), (5, 20), (15, 0),(-15, 0), (-5, 20))xyCoordsOuter = ((-10, 30), (10, 30), (40, -30),(30, -30), (20, -10), (-20, -10),(-30, -30), (-40, -30), (-10, 30))These two statements define the X- and Y-coordinates of the vertices that form the inner and outer profile of the letter “A.” The variable xyCoordsInner refers to the vertices of the inner profile, and the variable xyCoordsOuter refers to the vertices of the outer profile. for i in range(len(xyCoordsInner)-1):mySketch.Line(point1=xyCoordsInner[i],point2=xyCoordsInner[i+1])This loop creates the inner profile of the letter “A” in mySketch. Four lines are created using the X- and Y-coordinates of the vertices in xyCoordsInner to define the beginning point and the end point of each line. Note the following:∙Python uses only indentation to signify the start and the end ofa loop. Python does not use the brackets {} of C and C++.∙The len() function returns the number of coordinate pairs in xyCoordsInner—five in our example.∙The range() function returns a sequence of integers. In Python, as in C and C++, the index of an array starts at zero. In our example range(4) returns 0,1,2,3. For each iteration of the loop in theexample the variable i is assigned to the next value in the sequence of integers.Similarly, a second loop creates the outer profile of the “A” character. myPart = myModel.Part(name='Part A',dimensionality=THREE_D, type=DEFORMABLE_BODY)This statement creates a three-dimensional, deformable part named Part A in myModel. The new part is assigned to the variable myPart. myPart.BaseSolidExtrude(sketch=mySketch, depth=20.0)This statement creates a base solid extrude feature in myPart by extruding mySketch through a depth of 20.0.myViewport = session.Viewport(name='Viewport for Model A',origin=(20,20), width=150, height=100)This statement creates a new viewport named Viewport for Model A in session. The new viewport is assigned to the variable myViewport. The origin of the viewport is at (20, 20), and it has a width of 150 and a height of 100.myViewport.setValues(displayedObject=myPart)This statement tells Abaqus to display the new part, myPart, in the new viewport, myViewport.myViewport.partDisplayOptions.setValues(renderStyle=SHADED)This statement sets the render style of the part display options in myViewport to shaded. As a result, myPart appears in the shaded render style.3.2 Reading from an output databaseThe second example shows how you can use the Abaqus Scripting Interface to read an output database, manipulate the data, and display the resultsusing the Visualization module in Abaqus/CAE. The Abaqus Scripting Interface allows you to display the data even though you have not written it back to an output database. The script does the following:∙Opens the tutorial output database.∙Creates variables that refer to the first and second steps in the output database.∙Creates variables that refer to the last frame of the first and second steps.∙Creates variables that refer to the displacement field output in the last frame of the first and second steps.∙Creates variables that refer to the stress field output in the last frame of the first and second steps.∙Subtracts the displacement field output from the two steps and puts the result in a variable called deltaDisplacement.∙Subtracts the stress field output from the two steps and puts the result in a variable called deltaStress.∙Selects deltaDisplacement as the default deformed variable.∙Selects the von Mises invariant of deltaStress as the default field output variable.∙Plots a contour plot of the result.The resulting contour plot is shown in Figure 3–3.Figure 3–3 The resulting contour plot.Use the following commands to retrieve the script and the output database that is read by the script:abaqus fetch job=odbExampleabaqus fetch job=viewer_tutorial3.2.1 The example script"""odbExample.pyScript to open an output database, superimpose variablesfrom the last frame of different steps, and display a contourplot of the result."""from abaqus import *from abaqusConstants import *import visualizationmyViewport = session.Viewport(name='Superposition example',origin=(10, 10), width=150, height=100)# Open the tutorial output database.myOdb = visualization.openOdb(path='viewer_tutorial.odb')# Associate the output database with the viewport.myViewport.setValues(displayedObject=myOdb)# Create variables that refer to the first two steps.firstStep = myOdb.steps['Step-1']secondStep = myOdb.steps['Step-2']# Read displacement and stress data from the last frame# of the first two steps.frame1 = firstStep.frames[-1]frame2 = secondStep.frames[-1]displacement1 = frame1.fieldOutputs['U']displacement2 = frame2.fieldOutputs['U']stress1 = frame1.fieldOutputs['S']stress2 = frame2.fieldOutputs['S']# Find the added displacement and stress caused by# the loading in the second step.deltaDisplacement = displacement2 - displacement1deltaStress = stress2 - stress1# Create a Mises stress contour plot of the result.myViewport.odbDisplay.setDeformedVariable(deltaDisplacement)myViewport.odbDisplay.setPrimaryVariable(field=deltaStress,outputPosition=INTEGRATION_POINT,refinement=(INVARIANT, 'Mises'))myViewport.odbDisplay.display.setValues(plotState=(CONTOURS_ON_DEF,)) 3.2.2 How does the script work?This section explains each portion of the example script.from abaqus import *from abaqusConstants import *These statements make the basic Abaqus objects accessible to the script as well as all the Symbolic Constants defined in the Abaqus Scripting Interface.import visualizationThis statement provides access to the commands that replicate the functionality of the Visualization module in Abaqus/CAE (Abaqus/Viewer). myViewport = session.Viewport(name='Superposition example')This statement creates a new viewport named Superposition example in the session. The new viewport is assigned to the variable myViewport. The origin and the size of the viewport assume the default values.odbPath = 'viewer_tutorial.odb'This statement creates a path to the tutorial output database.myOdb = session.openOdb(path=odbPath)This statement uses the path variable odbPath to open the output database and to assign it to the variable myOdb.myViewport.setValues(displayedObject=myOdb)This statement displays the default plot of the output database in the viewport.firstStep = myOdb.steps['Step-1']secondStep = myOdb.steps['Step-2']These statements assign the first and second steps in the output database to the variables firstStep and secondStep.frame1 = firstStep.frames[-1]frame2 = secondStep.frames[-1]These statements assign the last frame of the first and second steps to the variables frame1 and frame2. In Python an index of 0 refers to the first item in a sequence. An index of –1 refers to the last item in a sequence.displacement1 = frame1.fieldOutputs['U']displacement2 = frame2.fieldOutputs['U']These statements assign the displacement field output in the last frame of the first and second steps to the variables displacement1 and displacement2.stress1 = frame1.fieldOutputs['S']stress2 = frame2.fieldOutputs['S']Similarly, these statements assign the stress field output in the last frame of the first and second steps to the variables stress1 and stress2. deltaDisplacement = displacement2 - displacement1This statement subtracts the displacement field output from the last frame of the two steps and puts the resulting field output into a new variable deltaDisplacement.deltaStress = stress2 - stress1Similarly, this statement subtracts the stress field output and puts the result in the variable deltaStress.myViewport.odbDisplay.setDeformedVariable(deltaDisplacement)This statement uses deltaDisplacement, the displacement field output variable that we created earlier, to set the deformed variable. This is the variable that Abaqus will use to display the shape of the deformed model.myViewport.odbDisplay.setPrimaryVariable(field=deltaStress,outputPosition=INTEGRATION_POINT,refinement=(INVARIANT, 'Mises'))This statement uses deltaStress, our stress field output variable, to set the primary variable. This is the variable that Abaqus will display in a contour or symbol plot.myViewport.odbDisplay.display.setValues(plotState=(CONTOURS_ON_DEF,)) The final statement sets the plot state to display a contour plot on the deformed model shape.3.3 SummaryThe examples illustrate how a script can operate on a model in a model database or on the data stored in an output database. The details of the commands in the examples are described in later sections; however, you should note the following:∙You can run a script from the Abaqus/CAE startup screen when you start a session. After a session has started, you can run a script from the File Run Script menu or from the command line interface.∙ A script is a sequence of commands stored in ASCII format and can be edited with a standard text editor.∙ A set of example scripts are provided with Abaqus. Use the abaqus fetch command to retrieve a script and any associated files.∙You must use the import statement to make the required set of Abaqus Scripting Interface commands available. For example, the statement import part provides the commands that create and operate on parts.∙ A command that creates something (an “object” in object-oriented programming terms) is called a constructor and starts with anuppercase character. For example, the following statement uses the Model constructor to create a model object.myModel = mdb.Model(name='Model A')The model object created ismdb.models['Model A']∙You can use a variable to refer to an object. Variables make your scripts easier to read and understand. myModel refers to a model object in the previous example.∙ A Python script can include a loop. The start and end of a loop is controlled by indentation in the script.∙Python includes a set of built-in functions. For example, the len() function returns the length of a sequence.You can use commands to replicate any operation that can be performed interactively when you are working with Abaqus/CAE; for example, creating a viewport, displaying a contour plot, and setting the step and the frame to display.。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
myPillarLoad = myModel.ConcentratedForce(name='pillarForce', createStepName='impact',region=(pillarVertices,), cf1=12.50E4)
# 在选择的顶点上施加 集中力
ABAQUS脚本接口
ABAQUS有限元分析软件二次开发环境提供的脚本接口,是基于Python语言进行的定
制开发。
在 ABAQUS/CAE 中 进 行 建 模 和 进 行后处理时,对话框中做的所有设 置 都 由 ABAQUS/CAE 从 内 部 发 出 与之对应的命令(command)。 ABAQUS 脚本接口直接与内核进行 通 信 ( communicate ) , 而 与 ABAQUS/CAE 的 图 形 用 户 界 面 ( GUI )无关。如果将所有的脚本 接口命令存储于文件中,该文件则
Python在ABAQUS二次开发中 的应用实例
主要内容
• 一、ABAQUS 脚本概述 • 二、Python 语言简介 • 三、ABAQUS脚本编写
一、ABAQUS 脚本概述
ABAQUS 脚本概述
ABAQUS软件简介
ABAQUS 是国际著名的 CAE 软件,它以解决实际工业问题能力和强大 的非线性功能赢得广泛声誉。航空工业是 ABAQUS 最重要的应用领域 之一,波音、空中客车、洛克希德•马丁等是其长期合作的用户。 ABAQUS 分析过程由三个步骤
编辑Python文件、调试Python脚本或插件; 创建guiLog脚本,录制所有的GUI动作;
通过GUI(guiLog)运行Python脚本或在ABAQUS/CAE之外运行Python脚本;
设置延迟(delay)和断点(breakpoint),并查看代码的执行情况; 在watch窗口中查看变量值等。
# 创建一个草图,并绘制两个矩形
# 对上面创建的两个矩形进行拉伸操作, 生成三维部件
通过以上语句,在Part模块中生成两个三维实体。
ABAQUS脚本编写
装配实体、导入边界条件
myAssembly = myModel.rootAssembly doorInstance = myAssembly.Instance(name='Door-1',part=door, dependent=OFF) #导入实体,完成装配
定义变量名、函数名的时候,避免使用保留字段。如: 保留字段 and \ not \ or break continue class 说明 逻辑‚与‛‚非‛‚或‛ 中止循环语句 继续执行下一次循环 定义类
def if \ else \ elif
print while from \ import return
ABAQUS 脚本概述
创建ABAQUS脚本
创建脚本有3种常用方法: ①在GUI建模时录制宏(macro)
File → Macro Manager 可以按需录制任何操作对应的命令
②直接编辑abaqus.rpy文件
建模时工作目录下自动生成abaqus.rpy文件 使用软件EditPlus可以直接打开编辑 保存.cae文件并退出后才能生成.rpy文件
from caeModules import *
如果需要用到各种符号常数,如单元类型C3D8R,还要导入符号常数模块:
from abaqusConstants import *
定义和导入对象
还需要导入相应的ABAQUS对象,包括
Session对象(包括视口、远程队列、视图对象) Mdb对象(包括Model对象和Job对象) Odb对象
for i in range(0,b3): if (iAnglelowfg[i]=='/'): for l in range(0,i-j-1): c3[k]=c3[k]+iAnglelowfg[j+l+1] j=i elif (iAnglelowfg[i]==']'):
Python 语言简介
保留字段
定义函数或者方法 条件判断语句
输出语句 循环语句 导入模块 返回函数计算结果
Python 语言简介
数据类型
数据类型主要有数字类型、字符串类型;
数字类型主要有四种:整型int、长整型long、浮点型float、复数型complex; Python语言可自动判断数据类型,不需要编写者定义说明类型,如:i=10.5,即可。 不需要用:float
pillarVertices = doorInstance.vertices.findAt(((-40,30,0),), ((40,0,0),) )
# 选择两个顶点 # 创建静力分析步 (static)
myModel.StaticStep(name='impact',previous='Initial', initialInc=1,
优点:界面直观,简单易懂; 缺点:操作步骤繁琐,不利于修改,缺乏通用性。
提交; 缺点:只包含模型节点信息,代码较多,修改不便;
③使用Python语言建模
优点:代码少,语言友好,可移 植性好,可进行参数化修改; 缺点:不够直观。
ABAQUS 脚本概述
二、Python 语言简介
Python 语言简介
基本规则
代码按级别从大到小解读,之间用操作符‚.‛连接。如:
mdb.models[‘Model-1’].materials[‘BPCOMPOSITE’].Depvar(n=5)
表示将模型‘model-1’的材料‘BPCOMPOSITE’里的子程序相关参数设为5。
加、减运算
乘、除、取余数运算 指数运算
不支持自加或自减运算,如:i++、i--; 但类似
i+=1
这样的语句是可以的。
三、ABAQUS脚本编写
ABAQUS脚本编写
定义和导入模块
在每个脚本文件的最开始处,首先要导入相应的ABAQUS模块;
每个步骤均有对应的模块,如part模块,material模块、assembly模块等,通 过以下语句可以直接导入cae模块的所有对象:
③借助PythonReader.exe软件
中国石油大学焦中良开发 可以实时获取CAE每步操作对应的脚本命令
ABAQUS 脚本概述
调试ABAQUS脚本
调试脚本有多种方法,这里介绍Abaqus自带的PDE中的调试。 PDE(Python Development Environment,Python开发环境)有以下功能:
组成:
前处理( ABAQUS/CAE ); 模拟计算(ABAQUS/Standard 或者ABAQUS/Explicit);
后处理( ABAQUS/CAE )。
建模过程主要集中在前处理步 骤中。
ABAQUS 脚本概述
ABAQUS建模方法
常用的ABAQUS建模方法主要有三种:
①在ABAQUS/CAE界面建模
GUI
命令行接口 (CLI)
命令
脚本
Python 解释器
rpy文件
ABAQUS/CAE
inp文件
ABAQUS/Standard ABAQUS/Explicit
称为脚本(script)。脚本由一系列
纯ASCII格式的Python语句组成,扩 展名一般为.py。
odb文件
ABAQUS 脚本概述
ABAQUS脚本接口
Python 语言简介
运算符
主要有赋值运算符、算术运算符、逻辑运算符、关系运算符; 下表按优先级排列,从上往下优先级增加。
运算符 or and not <, <=, > , >= , != ,== 描述 逻辑或 逻辑与 逻辑非 小于,小于等于,大于,大于等于,不等于,等于
+, *, /, % **
语句前加上 # 号,表示是注释内容,这个语句将不被执行; 使用中文注释,要在文件最开始加上:# -*- coding: UTF-8-*以换行来识别一个逻辑语句的结束。如果需要在一个物理行中编写多个逻辑语 句,需要用分号分开。如:x=1;y=2;z=3。如果一个逻辑语句太长需要分行写, 需要用反斜杠‚\‛进行连接(有括号括起来的内容就不用)。 不同代码块之间要注意用冒号和缩进来区分代码块之间的层次关系,如:
通过类似如下的语句导入对象:
from abaqus import *
ABAQUS脚本编写
创建新实体
myModel = mdb.models['Model-1'] myViewport=session.Viewport(name='Region syntax', origin=(20, 20), width=200, height=100) mySketch = myModel.Sketch(name='Sketch A', sheetSize=200.0) mySketch.rectangle(point1=(-40.0, 30.0),point2=(-10.0, 0.0)) mySketch.rectangle(point1=(10.0, 30.0),point2=(40.0, 0.0)) door = myModel.Part(name='Door',dimensionality =THREE_D, type=DEFORMABLE_BODY) door.BaseSolidExtrude(sketch=mySketch, depth=20.0) #建立新模型Model-1 # 创建新的视口