【ABAQUS】【PYTHON】参数化有限元example 4/14: Cargo crane

于 2023-05-23 21:58:43 发布
阅读量1k 收藏 2
点赞数 1
文章标签： python 数学建模 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hmywillstronger/article/details/130834814
版权

文章目录

Program introduction

在这里插入图片描述
A light-service, cargo crane is shown above. You have been asked to determine the static deflections of the crane when it carries a load of 10 kN(you could set is as a list of Parameter variable).You should also identify the critical members and joints in the structure: i.e, those with the highest stresses and loads.Because this is a static analysis you will analyze the cargo crane using Abaqus/Standard.

Overview about code

#
# Getting Started with Abaqus: Interactive Edition
#
# Script for static crane example
#


def GetBlockPosition(modelName, blockPrefix):
    if blockPrefix == '':
        return len(mdb.models[modelName].keywordBlock.sieBlocks)-1
    pos = 0
    for block in mdb.models[modelName].keywordBlock.sieBlocks:
        if block[0:len(blockPrefix)].lower()==blockPrefix.lower():
            return pos
        pos=pos+1
    return -1

from abaqus import *
from abaqusConstants import *
session.viewports['Viewport: 1'].makeCurrent()
session.viewports['Viewport: 1'].maximize()
from caeModules import *
from driverUtils import executeOnCaeStartup
executeOnCaeStartup()
Mdb()

session.viewports['Viewport: 1'].setValues(displayedObject=None)
##
##  Sketch profile of truss
##
p = mdb.models['Model-1'].Part(name='Truss', dimensionality=THREE_D, 
    type=DEFORMABLE_BODY)
p.ReferencePoint(point=(0.0, 0.0, 0.0))

p = mdb.models['Model-1'].parts['Truss']
session.viewports['Viewport: 1'].setValues(displayedObject=p)

d, r = p.datums, p.referencePoints
p.DatumPointByOffset(point=r[1], vector=(0.0, 1.0, 0.0))
p.DatumPointByOffset(point=r[1], vector=(8.0, 1.5, 0.9))
p.DatumPlaneByThreePoints(point1=r[1], point2=d[3], point3=d[2])
p.DatumAxisByPrincipalAxis(principalAxis=YAXIS)

session.viewports['Viewport: 1'].view.fitView()

t = p.MakeSketchTransform(sketchPlane=d[4], sketchUpEdge=d[5], 
    sketchPlaneSide=SIDE1, sketchOrientation=LEFT, origin=(0.0, 0.0, 0.0))
s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__', 
    sheetSize=683.38, gridSpacing=17.08, transform=t)
g, v, d1, c = s.geometry, s.vertices, s.dimensions, s.constraints
s.setPrimaryObject(option=SUPERIMPOSE)
p = mdb.models['Model-1'].parts['Truss']
p.projectReferencesOntoSketch(sketch=s, filter=COPLANAR_EDGES)
session.viewports['Viewport: 1'].view.setValues(nearPlane=648.075, 
    farPlane=719.271, width=13.6266, height=9.28111, cameraPosition=(-71.5628, 
    0.978423, 679.645), cameraTarget=(4.83613, 0.978423, 0.544065))

s.Line(point1=(0.0, 0.0), point2=(8.05046582503149, 1.5))
s.CoincidentConstraint(entity1=v.findAt((0.0, 0.0)), entity2=g.findAt((0.0, 
    0.5)))

s.Line(point1=(8.05046582503149, 1.5), point2=(0.0, 1.0))

s.Line(point1=(0.0, 1.0), point2=(1.59409310185916, 0.297018794285658))
s.CoincidentConstraint(entity1=v.findAt((1.594093, 0.297019)), 
    entity2=g.findAt((4.025233, 0.75)))

s.Line(point1=(1.59409310185916, 0.297018794285658),
    point2=(2.30592731982451, 1.14321701190598))
s.CoincidentConstraint(entity1=v.findAt((2.305927, 1.143217)), 
    entity2=g.findAt((4.025233, 1.25)))

s.Line(point1=(2.30592731982451, 1.14321701190598),
    point2=(3.26033977276254, 0.607481575033539))
s.CoincidentConstraint(entity1=v.findAt((3.26034, 0.607482)),
    entity2=g.findAt((4.025233, 0.75)))

s.Line(point1=(3.26033977276254, 0.607481575033539),
    point2=(4.16525059699136, 1.25869624736747))
s.CoincidentConstraint(entity1=v.findAt((4.165251, 1.258696)), 
    entity2=g.findAt((4.025233, 1.25)))

s.Line(point1=(4.16525059699136, 1.25869624736747),
    point2=(4.95150583156061, 0.922587451305882))
s.CoincidentConstraint(entity1=v.findAt((4.951506, 0.922587)), 
    entity2=g.findAt((4.025233, 0.75)))

s.breakCurve(curve1=g.findAt((4.025233, 0.75)),
    point1=(0.733189206279801, 0.182644009590149),
    curve2=g.findAt((1.95001, 0.720118)),
    point2=(1.62787567272877, 0.433001518249512))

s.breakCurve(curve1=g.findAt((4.822279, 0.898509)),
    point1=(2.34362044857835, 0.415118813514709),
    curve2=g.findAt((2.783134, 0.875349)),
    point2=(3.22040910681461, 0.701241612434387))

s.breakCurve(curve1=g.findAt((5.655403, 1.053741)),
    point1=(4.04351950354929, 0.772772312164307),
    curve2=g.findAt((4.558378, 1.090642)),
    point2=(5.02767302451382, 0.95159912109375))

s.breakCurve(curve1=g.findAt((4.025233, 1.25)),
    point1=(1.55629884485765, 1.09466052055359),
    curve2=g.findAt((1.95001, 0.720118)),
    point2=(2.32572264036564, 1.02312982082367))

s.breakCurve(curve1=g.findAt((5.178197, 1.321609)),
    point1=(3.79300780849022, 1.23772192001343),
    curve2=g.findAt((3.712795, 0.933089)),
    point2=(4.168774592922, 1.18407392501831))

s.VerticalDimension(vertex1=v.findAt((0.0, 1.0)),
    vertex2=v.findAt((0.0, 0.0)), 
    textPoint=(-0.304643334343144, 0.0216999053955078), value=1.0)
s.HorizontalDimension(vertex1=v.findAt((0.0, 0.0)),
    vertex2=v.findAt((8.050466, 1.5)),
    textPoint=(6.26233672422377, -0.443249702453613), value=8.05046582503149)

s.ParallelConstraint(entity1=g.findAt((1.152964, 1.071609)), entity2=g.findAt((
    3.235589, 1.200957)))

s.ParallelConstraint(entity1=g.findAt((3.235589, 1.200957)), entity2=g.findAt((
    6.107858, 1.379348)))

s.ParallelConstraint(entity1=g.findAt((0.797047, 0.148509)), entity2=g.findAt((
    2.427216, 0.45225)))

s.ParallelConstraint(entity1=g.findAt((2.427216, 0.45225)), entity2=g.findAt((
    4.105923, 0.765035)))

s.ParallelConstraint(entity1=g.findAt((4.105923, 0.765035)), entity2=g.findAt((
    6.500986, 1.211294)))

s.EqualLengthConstraint(entity1=g.findAt((0.797047, 0.148509)), 
    entity2=g.findAt((2.427216, 0.45225)))

s.EqualLengthConstraint(entity1=g.findAt((2.39114, 0.445528)), 
    entity2=g.findAt((4.033769, 0.751591)))

s.EqualLengthConstraint(entity1=g.findAt((3.985233, 0.742547)), 
    entity2=g.findAt((6.416373, 1.195528)))

s.EqualLengthConstraint(entity1=g.findAt((1.152964, 1.071609)), 
    entity2=g.findAt((3.235589, 1.200957)))

s.EqualLengthConstraint(entity1=g.findAt((3.458891, 1.214826)), 
    entity2=g.findAt((6.33116, 1.393217)))

mdb.models['Model-1'].ConstrainedSketch(name='Truss', objectToCopy=s)

p = mdb.models['Model-1'].parts['Truss']
d = p.datums
p.Wire(sketchPlane=d[4], sketchUpEdge=d[5], sketchPlaneSide=SIDE1, 
    sketchOrientation=LEFT, sketch=s)
s.unsetPrimaryObject()
del mdb.models['Model-1'].sketches['__profile__']

session.viewports['Viewport: 1'].view.fitView()

p = mdb.models['Model-1'].parts['Truss']
d, r = p.datums, p.referencePoints
p.DatumPointByOffset(point=d[2], vector=(0.0, 0.0, 2.0))
p.DatumPointByOffset(point=r[1], vector=(0.0, 0.0, 2.0))
p.DatumPointByOffset(point=d[3], vector=(0.0, 0.0, 0.2))
p.DatumPlaneByThreePoints(point1=d[8], point2=d[9], point3=d[7])

t = p.MakeSketchTransform(sketchPlane=d[10], sketchUpEdge=d[5], 
    sketchPlaneSide=SIDE1, sketchOrientation=LEFT, origin=(4.122203, 0.75, 
    1.536252))
s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__', 
    sheetSize=683.38, gridSpacing=17.08, transform=t)
g, v, d, c = s.geometry, s.vertices, s.dimensions, s.constraints
s.setPrimaryObject(option=SUPERIMPOSE)
p.projectReferencesOntoSketch(sketch=s, filter=COPLANAR_EDGES)
s.retrieveSketch(sketch=mdb.models['Model-1'].sketches['Truss'])
s.move(vector=(-4.14820681508444, -0.75), objectList=(g.findAt((0.0, 0.5)), 
    g.findAt((1.006308, 0.6875)), g.findAt((2.348053, 0.770833)), g.findAt((
    3.354361, 0.958333)), g.findAt((4.696105, 1.041667)), g.findAt((5.702413, 
    1.229167)), g.findAt((1.006308, 0.1875)), g.findAt((3.018925, 0.5625)), 
    g.findAt((5.031541, 0.9375)), g.findAt((7.044158, 1.3125)), g.findAt((
    1.341744, 1.083333)), g.findAt((6.708722, 1.416667)), g.findAt((4.025233, 
    1.25)), v.findAt((8.050466, 1.5)), v.findAt((0.0, 1.0))))
d = p.datums
p.Wire(sketchPlane=d[10], sketchUpEdge=d[5], sketchPlaneSide=SIDE1, 
    sketchOrientation=LEFT, sketch=s)
s.unsetPrimaryObject()
del mdb.models['Model-1'].sketches['__profile__']

##
##  dummy part
##
p = mdb.models['Model-1'].Part(name='Truss-all', 
    objectToCopy=mdb.models['Model-1'].parts['Truss'])
session.viewports['Viewport: 1'].setValues(displayedObject=p)
v = p.vertices
p.WirePolyLine(points=((v.findAt(coordinates=(2.0, 0.375, 1.775)), v.findAt(
    coordinates=(2.0, 0.375, 0.225))), (v.findAt(coordinates=(2.0, 0.375, 
    0.225)), v.findAt(coordinates=(2.666667, 1.166667, 1.7))), (v.findAt(
    coordinates=(2.666667, 1.166667, 1.7)), v.findAt(coordinates=(2.666667, 
    1.166667, 0.3))), (v.findAt(coordinates=(4.0, 0.75, 1.55)), v.findAt(
    coordinates=(4.0, 0.75, 0.45))), (v.findAt(coordinates=(4.0, 0.75, 0.45)), 
    v.findAt(coordinates=(5.333333, 1.333333, 1.4))), (v.findAt(coordinates=(
    5.333333, 1.333333, 1.4)), v.findAt(coordinates=(5.333333, 1.333333, 
    0.6))), (v.findAt(coordinates=(5.333333, 1.333333, 0.6)), v.findAt(
    coordinates=(6.0, 1.125, 1.325))), (v.findAt(coordinates=(6.0, 1.125, 
    1.325)), v.findAt(coordinates=(6.0, 1.125, 0.675)))), mergeType=IMPRINT, 
    meshable=ON)
##
##  create cross brace part in the assembly module
##

a = mdb.models['Model-1'].rootAssembly
session.viewports['Viewport: 1'].setValues(displayedObject=a)
##  Set coordinate system (done by default)
a.DatumCsysByDefault(CARTESIAN)
p = mdb.models['Model-1'].parts['Truss']
a.Instance(name='Truss-1', part=p, dependent=ON)
p = mdb.models['Model-1'].parts['Truss-all']
a.Instance(name='Truss-all-1', part=p, dependent=ON)
a.PartFromBooleanCut(name='Cross brace', 
    instanceToBeCut=a.instances['Truss-all-1'], 
    cuttingInstances=(a.instances['Truss-1'], ))
p = mdb.models['Model-1'].parts['Cross brace']
a.Instance(name='Cross brace-1', part=p, dependent=ON)
a.suppressFeatures(('Truss-1', 'Truss-all-1', ))
a.features['Truss-1'].resume()

p = mdb.models['Model-1'].parts['Cross brace']
session.viewports['Viewport: 1'].setValues(displayedObject=p)
##
##  Create beam profiles and beam sections
##
mdb.models['Model-1'].BoxProfile(name='MainBoxProfile', b=0.05, 
    a=0.1, uniformThickness=ON, t1=0.005)
mdb.models['Model-1'].BoxProfile(name='BraceBoxProfile', b=0.03, 
    a=0.03, uniformThickness=ON, t1=0.003)
mdb.models['Model-1'].BeamSection(name='MainMemberSection', 
    profile='MainBoxProfile', poissonRatio=0.25,
    integration=BEFORE_ANALYSIS, table=((2.e11, 8.e10),))
mdb.models['Model-1'].BeamSection(name='BracingSection', 
    profile='BraceBoxProfile', poissonRatio=0.25,
    integration=BEFORE_ANALYSIS, table=((2.e11, 8.e10),))
##
##  Flip tangent directions
##
##p = mdb.models['Model-1'].parts['Truss']
##e = p.edges
##edges = e
##regions = regionToolset.Region(edges=edges)
##p.flipTangent(regions=regions)
####
##edges = e.findAt(((4.5, 0.84375, 0.50625), ), ((2.5, 0.46875, 0.28125), ), ((
##    0.5, 0.09375, 0.05625), ), ((4.5, 0.84375, 1.49375), ), ((2.5, 0.46875, 
##    1.71875), ), ((0.5, 0.09375, 1.94375), ))
##regions = regionToolset.Region(edges=edges)
##p.flipTangent(regions=regions)
##
##  Assign beam sections to the cross brace
##
p = mdb.models['Model-1'].parts['Cross brace']
e = p.edges
edges = e.findAt(((2.666667, 1.166667, 1.35), ),
    ((2.166667, 0.572917, 0.59375), ), ((2.0, 0.375, 1.3875), ),
    ((6.0, 1.125, 1.1625), ), ((5.5, 1.28125, 0.78125), ),
    ((5.333333, 1.333333, 1.2), ), ((4.333333, 0.895833, 0.6875), ),
    ((4.0, 0.75, 1.275), ))
region = regionToolset.Region(edges=edges)
p.SectionAssignment(region=region, sectionName='BracingSection')
##
##  Assign beam sections to the internal bracing
##
p = mdb.models['Model-1'].parts['Truss']
e = p.edges
edges = e.findAt(((3.0, 1.0625, 0.3375), ), ((5.5, 1.28125, 0.61875), ),
    ((4.333333, 0.895833, 0.4875), ), ((0.5, 0.84375, 0.05625), ),
    ((2.166667, 0.572917, 0.24375), ), ((3.0, 1.0625, 1.6625), ),
    ((5.5, 1.28125, 1.38125), ), ((4.333333, 0.895833, 1.5125), ),
    ((0.5, 0.84375, 1.94375), ), ((2.166667, 0.572917, 1.75625), ))
region = regionToolset.Region(edges=edges)
p.SectionAssignment(region=region, sectionName='BracingSection')
##
##  Assign beam sections to the main members
##
p = mdb.models['Model-1'].parts['Truss']
e = p.edges
edges = e.findAt(((4.5, 0.84375, 0.50625), ), ((4.666667, 1.291667, 0.525), ), 
    ((6.5, 1.21875, 0.73125), ), ((7.333333, 1.458333, 0.825), ),
    ((2.5, 0.46875, 0.28125), ), ((2.0, 1.125, 0.225), ),
    ((0.5, 0.09375, 0.05625), ), ((4.5, 0.84375, 1.49375), ),
    ((4.666667, 1.291667, 1.475), ), ((6.5, 1.21875, 1.26875), ),
    ((7.333333, 1.458333, 1.175), ), ((2.5, 0.46875, 1.71875), ),
    ((2.0, 1.125, 1.775), ), ((0.5, 0.09375, 1.94375), ))
region = regionToolset.Region(edges=edges)
p.SectionAssignment(region=region, sectionName='MainMemberSection')
##
##  Assign beam section orientations to truss 'B'
##
p = mdb.models['Model-1'].parts['Truss']
e = p.edges
edges = e.findAt(((4.5, 0.84375, 0.50625), ), ((3.0, 1.0625, 0.3375), ),
    ((4.666667, 1.291667, 0.525), ), ((5.5, 1.28125, 0.61875), ),
    ((6.5, 1.21875, 0.73125), ), ((7.333333, 1.458333, 0.825), ),
    ((4.333333, 0.895833, 0.4875), ), ((2.5, 0.46875, 0.28125), ),
    ((0.5, 0.84375, 0.05625), ), ((2.0, 1.125, 0.225), ),
    ((2.166667, 0.572917, 0.24375), ), ((0.5, 0.09375, 0.05625), ))
region=regionToolset.Region(edges=edges)
p.assignBeamSectionOrientation(region=region, method=N1_COSINES, n1=(-0.1118, 
    0.0, 0.9936))
##
##  Assign beam section orientations to truss 'A'
##
p = mdb.models['Model-1'].parts['Truss']
e = p.edges
edges = e.findAt(((4.5, 0.84375, 1.49375), ), ((3.0, 1.0625, 1.6625), ),
    ((4.666667, 1.291667, 1.475), ), ((5.5, 1.28125, 1.38125), ),
    ((6.5, 1.21875, 1.26875), ), ((7.333333, 1.458333, 1.175), ),
    ((4.333333, 0.895833, 1.5125), ), ((2.5, 0.46875, 1.71875), ),
    ((0.5, 0.84375, 1.94375), ), ((2.0, 1.125, 1.775), ),
    ((2.166667, 0.572917, 1.75625), ), ((0.5, 0.09375, 1.94375), ))
region=regionToolset.Region(edges=edges)
p.assignBeamSectionOrientation(region=region, method=N1_COSINES, n1=(-0.1118, 
    0.0, -0.9936))
##
##  Assign beam section orientations to 'Cross brace'
##
p = mdb.models['Model-1'].parts['Cross brace']
e = p.edges
edges = e.findAt(((2.666667, 1.166667, 1.35), ), ((2.166667, 0.572917, 
    0.59375), ), ((2.0, 0.375, 1.3875), ), ((6.0, 1.125, 1.1625), ), ((5.5, 
    1.28125, 0.78125), ), ((5.333333, 1.333333, 1.2), ), ((4.333333, 0.895833, 
    0.6875), ), ((4.0, 0.75, 1.275), ))
region=regionToolset.Region(edges=edges)
p.assignBeamSectionOrientation(region=region, method=N1_COSINES,
    n1=(0.0, 1.0, 0.0))

session.viewports['Viewport: 1'].setValues(displayedObject=a)
a.regenerate()
##
##
session.viewports['Viewport: 1'].assemblyDisplay.setValues(
    visibleInstances=('Truss-1', 'Cross brace-1'))
session.viewports['Viewport: 1'].assemblyDisplay.geometryOptions.setValues(
    geometryEdgesInShaded=OFF, datumPoints=OFF, datumAxes=OFF, datumPlanes=OFF,
    datumCoordSystems=OFF, referencePointLabels=OFF, referencePointSymbols=OFF)
##
##  Translate the truss
##
p = a.instances['Truss-1']
p.translate(vector=(0.0, -0.5, -1.0))
##
##  Translate the cross brace
##
p = a.instances['Cross brace-1']
p.translate(vector=(0.0, -0.5, -1.0))


##
##  Create geometry sets
##
session.viewports['Viewport: 1'].assemblyDisplay.setValues(
    visibleInstances=('Truss-1', ))
session.viewports['Viewport: 1'].assemblyDisplay.geometryOptions.setValues(
    datumPoints=OFF)

v = a.instances['Truss-1'].vertices
verts = v.findAt(((0.0, 0.5, -1.0), ), ((0.0, -0.5, -1.0), ), ((0.0, 0.5, 
    1.0), ), ((0.0, -0.5, 1.0), ))
a.Set(vertices=verts, name='Attach')

verts = v.findAt(((8.0, 1.0, 0.1), ))
a.Set(vertices=verts, name='Tip-a')

verts = v.findAt(((8.0, 1.0, -0.1), ))
a.Set(vertices=verts, name='Tip-b')

e = a.instances['Truss-1'].edges
edges = e.findAt(((6.5, 0.71875, 0.26875), ))
a.Set(edges=edges, name='Leg-a')

edges = e.findAt(((6.5, 0.71875, -0.26875), ))
a.Set(edges=edges, name='Leg-b')

edges = e.findAt(((4.333333, 0.395833, 0.5125), ))
a.Set(edges=edges, name='Inner-a')

edges = e.findAt(((4.333333, 0.395833, -0.5125), ))
a.Set(edges=edges, name='Inner-b')

session.viewports['Viewport: 1'].assemblyDisplay.setValues(
    visibleInstances=('Cross brace-1', ))
session.viewports['Viewport: 1'].view.setValues(
    cameraPosition=(7.4736, 8.3559, 20.002),
    cameraUpVector=(-0.34023, 0.72044, -0.60432))

session.viewports['Viewport: 1'].assemblyDisplay.setValues(
    visibleInstances=('Truss-1', 'Cross brace-1'))
session.viewports['Viewport: 1'].view.setValues(session.views['Iso'])

##
##  Create a static general step
##
mdb.models['Model-1'].StaticStep(name='Tip load', 
    previous='Initial', description='Static tip load on crane', 
    timePeriod=1, adiabatic=OFF, maxNumInc=100, 
    stabilization=None, timeIncrementationMethod=AUTOMATIC, initialInc=1, 
    minInc=1e-05, maxInc=1, matrixSolver=SOLVER_DEFAULT, amplitude=RAMP, 
    extrapolation=LINEAR, fullyPlastic="")
session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Tip load')
##
##  Modify output requests
##
mdb.models['Model-1'].fieldOutputRequests['F-Output-1'].setValues(
    variables=('U', 'RF', 'SF'))
mdb.models['Model-1'].historyOutputRequests['H-Output-1'].setValues(
    variables=PRESELECT)

##
##  Create constraints between the tips of the truss
##
session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=ON)
mdb.models['Model-1'].Equation(name='TipConstraint-1', 
    terms=((1.0, 'Tip-a', 1), (-1.0, 'Tip-b', 1)))
mdb.models['Model-1'].Constraint('TipConstraint-2', 
    mdb.models['Model-1'].constraints['TipConstraint-1'])
mdb.models['Model-1'].constraints['TipConstraint-2'].setValues(
    terms=((1.0, 'Tip-a', 2), (-1.0, 'Tip-b', 2)))
##
##  Create JOIN connectors between truss and bracing
##

v1 = a.instances['Cross brace-1'].vertices
v2 = a.instances['Truss-1'].vertices

a.WirePolyLine(points=((v1.findAt(coordinates=(2.0, -0.125, 0.775)), v2.findAt(
    coordinates=(2.0, -0.125, 0.775))), (v1.findAt(coordinates=(2.666667, 
    0.666667, 0.7)), v2.findAt(coordinates=(2.666667, 0.666667, 0.7))), (
    v1.findAt(coordinates=(2.0, -0.125, -0.775)), v2.findAt(coordinates=(2.0, 
    -0.125, -0.775))), (v1.findAt(coordinates=(2.666667, 0.666667, -0.7)), 
    v2.findAt(coordinates=(2.666667, 0.666667, -0.7))), (v1.findAt(
    coordinates=(4.0, 0.25, -0.55)), v2.findAt(coordinates=(4.0, 0.25, 
    -0.55))), (v1.findAt(coordinates=(4.0, 0.25, 0.55)), v2.findAt(
    coordinates=(4.0, 0.25, 0.55))), (v1.findAt(coordinates=(5.333333, 
    0.833333, 0.4)), v2.findAt(coordinates=(5.333333, 0.833333, 0.4))), (
    v1.findAt(coordinates=(5.333333, 0.833333, -0.4)), v2.findAt(coordinates=(
    5.333333, 0.833333, -0.4))), (v1.findAt(coordinates=(6.0, 0.625, -0.325)), 
    v2.findAt(coordinates=(6.0, 0.625, -0.325))), (v1.findAt(coordinates=(6.0, 
    0.625, 0.325)), v2.findAt(coordinates=(6.0, 0.625, 0.325)))), 
    mergeType=IMPRINT, meshable=OFF)

e1 = a.edges
edges1 = e1.findAt(((6.000025, 0.625, 0.325), ), ((6.000025, 0.625, -0.325), ), 
    ((5.333358, 0.833333, -0.4), ), ((5.333358, 0.833333, 0.4), ), ((4.000025, 
    0.25, 0.55), ), ((4.000025, 0.25, -0.55), ), ((2.666692, 0.666667, -0.7), 
    ), ((2.000025, -0.125, -0.775), ), ((2.666692, 0.666667, 0.7), ), ((
    2.000025, -0.125, 0.775), ))
a.Set(edges=edges1, name='Wire-1-Edge-1')

mdb.models['Model-1'].ConnectorSection(name='ConnSect-1', 
    translationalType=JOIN)

region=a.sets['Wire-1-Edge-1']
a.SectionAssignment(sectionName='ConnSect-1', region=region)

session.viewports['Viewport: 1'].assemblyDisplay.setValues(loads=ON, bcs=ON,
    predefinedFields=ON, interactions=OFF)
##
##  Apply encastre bc to set 'Attach'
##
region = a.sets['Attach']
mdb.models['Model-1'].EncastreBC(name='Fixed end', createStepName='Tip load', 
    region=region)
##
##  Apply concentrated force to set 'Tip-b'
##
region = a.sets['Tip-b']
mdb.models['Model-1'].ConcentratedForce(name='Tip load', 
    createStepName='Tip load', region=region, cf2=-10000.0)
##
##  Assign global seed
##
p = mdb.models['Model-1'].parts['Truss']
p.seedPart(size=2.0)
p = mdb.models['Model-1'].parts['Cross brace']
p.seedPart(size=2.0)
##
##  Assign element type
##
elemType1 = mesh.ElemType(elemCode=B33)

p = mdb.models['Model-1'].parts['Cross brace']
e = p.edges
edges = e
pickedRegions =(edges, )
p.setElementType(regions=pickedRegions, elemTypes=(elemType1, ))

p = mdb.models['Model-1'].parts['Truss']
e = p.edges
edges = e
pickedRegions =(edges, )
p.setElementType(regions=pickedRegions, elemTypes=(elemType1, ))
##
##  Generate mesh
##
p = mdb.models['Model-1'].parts['Truss']
p.generateMesh()
p = mdb.models['Model-1'].parts['Cross brace']
p.generateMesh()

##
##  Add keywords
##
mdb.models['Model-1'].keywordBlock.synchVersions()
mdb.models['Model-1'].keywordBlock.insert(GetBlockPosition('Model-1', '*End Assembly')-1, """*NORMAL, TYPE=ELEMENT
Inner-a,  Inner-a, -0.3962,  0.9171,  0.0446
Inner-b,  Inner-b,  0.3962, -0.9171,  0.0446
Leg-a,    Leg-a,   -0.1820,  0.9829,  0.0205
Leg-b,    Leg-b,    0.1820, -0.9829,  0.0205""")
##
##  Create job
##
mdb.Job(name='Crane', model='Model-1', 
    description='3-D model of light-service cargo crane')

a.regenerate()
session.viewports['Viewport: 1'].setValues(displayedObject=a)
##
##  Save model database
##
mdb.saveAs('Crane.cae')

1.Getting Started with Abaqus: Interactive Edition

片段

def GetBlockPosition(modelName, blockPrefix):
    if blockPrefix == '':
        return len(mdb.models[modelName].keywordBlock.sieBlocks)-1
    pos = 0
    for block in mdb.models[modelName].keywordBlock.sieBlocks:
        if block[0:len(blockPrefix)].lower()==blockPrefix.lower():
            return pos
        pos=pos+1
    return -1

from abaqus import *
from abaqusConstants import *
session.viewports['Viewport: 1'].makeCurrent()
session.viewports['Viewport: 1'].maximize()
from caeModules import *
from driverUtils import executeOnCaeStartup
executeOnCaeStartup()
Mdb()

执行结果

在这里插入图片描述## 内容解析

引入 abaqusConstants 类

abaqusConstants是Abaqus Python API中的一个模块，其中包含了Abaqus中使用的常量和标志位的定义。通过导入abaqusConstants模块，Python脚本可以使用这些常量和标志位来调用Abaqus的函数和方法，以便进行模拟、后处理和其他操作。

这个模块包含了各种常量，例如节点类型、单元类型、边界条件类型、材料模型类型、积分点类型等等。使用这些常量可以方便地调用Abaqus API的函数和方法，而无需记住这些常量的具体值。

例如，通过abaqusConstants模块，可以使用NODE常量来表示节点的类型，而不是直接使用整数值1。这样可以使代码更清晰易读，并减少错误的可能性。

下面是一些abaqusConstants模块中定义的常量的示例：

from abaqusConstants import *

# 定义节点类型常量
NODE = NODAL

# 定义单元类型常量
ELEMENT = C3D8

# 定义材料模型类型常量
MATERIAL_MODEL = ISOTROPIC_HARDENING

# 定义积分点类型常量
INTEGRATION_POINT = GAUSS_POINT_2D

注意，当导入abaqusConstants模块时，可以使用通配符符号*来导入所有定义的常量，例如from abaqusConstants import *。然而，这种方法可能会导致命名冲突和代码难以维护，因此建议仅导入需要使用的常量。

引入session 类

session是Abaqus/CAE中的一个对象，它代表了当前Abaqus会话的状态和操作。在Abaqus/CAE中，用户可以通过GUI界面进行模型创建、修改和后处理等操作，而session对象则是在Python脚本中进行这些操作的主要接口。

通过session对象，Python脚本可以访问和修改Abaqus/CAE中的各种对象和属性，例如模型、材料、边界条件、荷载、分析步等等。可以使用session对象的方法来创建模型、修改模型属性、运行分析、执行后处理等操作。

以下是一些使用session对象的示例：

from abaqus import *
from abaqusConstants import *
from caeModules import *

# 设置当前视口
session.viewports['Viewport: 1'].makeCurrent()

# 创建一个新模型
myModel = mdb.Model(name='MyModel')

# 创建一个新部件并设置属性
myPart = myModel.Part(name='MyPart', dimensionality=THREE_D, type=DEFORMABLE_BODY)

# 创建一个新材料
myMaterial = myModel.Material(name='MyMaterial')

# 创建一个新荷载
myLoad = myModel.loads['MyLoad']

# 运行分析
myJob = mdb.Job(name='MyJob', model=myModel)
myJob.submit()

在这个示例中，使用session对象的viewports属性来设置当前视口。然后，创建了一个新的Abaqus模型，并使用session对象的Model属性来访问和修改模型属性。接下来，创建了一个新部件、一个新材料和一个新荷载，并使用session对象的loads属性来访问和修改荷载属性。最后，创建了一个新的Abaqus作业，并使用session对象的Job属性来访问和修改作业属性，然后提交作业以运行分析。

需要注意的是，session对象只能在Abaqus/CAE中使用，无法直接在Python脚本中使用。在Python脚本中，可以使用Abaqus Python API中的其他对象和函数来进行模拟和后处理操作。

引入caeModules,driverUtils 类

caeModules和driverUtils是Abaqus Python API中的两个模块，用于在Python脚本中调用Abaqus/CAE中的各种模块和函数。

caeModules模块包含了Abaqus/CAE中各种模块的定义，例如Part、Assembly、Interaction、Load等等。通过导入caeModules模块，Python脚本可以使用这些模块来创建、修改和管理Abaqus模型。

以下是一个使用caeModules模块的示例：

from abaqus import *
from abaqusConstants import *
from caeModules import *

# 创建一个新模型
myModel = mdb.Model(name='MyModel')

# 创建一个新部件并设置属性
myPart = myModel.Part(name='MyPart', dimensionality=THREE_D, type=DEFORMABLE_BODY)

# 创建一个新荷载
myLoad = myModel.loads['MyLoad']

在这个示例中，使用caeModules模块的Model属性来创建一个新的Abaqus模型，然后使用Part属性来创建一个新的部件，并使用loads属性来创建一个新的荷载。

driverUtils模块包含了一些与Abaqus/CAE的驱动程序相关的函数和类。例如，通过executeOnCaeStartup()函数，可以在Abaqus/CAE启动时自动执行Python脚本中的指定函数。另外，Driver类可以用于在Python脚本中控制Abaqus/CAE的交互式会话。

以下是一个使用driverUtils模块的示例：

from abaqus import *
from abaqusConstants import *
from caeModules import *
from driverUtils import executeOnCaeStartup, Driver

# 在Abaqus/CAE启动时自动执行hello()函数
def hello():
    print('Hello, Abaqus!')

executeOnCaeStartup(hello)

# 创建一个新模型
myModel = mdb.Model(name='MyModel')

# 打开Abaqus/CAE的交互式会话
session.viewports['Viewport: 1'].makeCurrent()
session.viewports['Viewport: 1'].maximize()
myDriver = Driver()
myDriver.run()

在这个示例中，使用driverUtils模块的executeOnCaeStartup()函数来注册一个名为hello()的函数，在Abaqus/CAE启动时自动执行。然后，使用Driver类来打开Abaqus/CAE的交互式会话，并使用run()方法来运行会话。

executeOnCaeStartup()，Mdb()

executeOnCaeStartup()和Mdb()都是driverUtils模块中定义的函数。

executeOnCaeStartup()函数用于在Abaqus/CAE**启动时自动执行**Python脚本中的指定函数。在这个函数中可以指定一个Python函数，当Abaqus/CAE启动时就会自动执行这个函数。这个函数可以用于设置一些全局变量、初始化一些参数或执行一些特定的操作。示例代码如下：

from driverUtils import executeOnCaeStartup

def myFunction():
    print('Hello from myFunction!')

executeOnCaeStartup(myFunction)

在这个示例中，myFunction()函数将在Abaqus/CAE启动时自动执行，并输出一条消息。

Mdb()函数用于创建一个新的Abaqus模型数据库，它返回一个表示新模型数据库的对象。在创建新模型数据库后，可以使用模型数据库对象来创建新的模型、部件、材料、荷载等。示例代码如下：

from abaqus import *
from abaqusConstants import *
from caeModules import *
from driverUtils import executeOnCaeStartup

executeOnCaeStartup()

# 创建一个新模型数据库
myModelDB = Mdb()

在这个示例中，使用driverUtils模块的executeOnCaeStartup()函数来执行一些初始化操作。然后，使用Mdb()函数创建一个新的Abaqus模型数据库，并将其赋值给一个变量myModelDB。此时，myModelDB表示一个空的Abaqus模型数据库对象。

定义GetBlockPosition的函数

def GetBlockPosition(modelName, blockPrefix):
# modelName：要搜索的Abaqus模型（model）的名称。
# blockPrefix：要查找的关键字块的前缀（prefix）。
    if blockPrefix == '':
        return len(mdb.models[modelName].keywordBlock.sieBlocks)-1
        # 函数首先检查blockPrefix是否为空字符串。如果是，则返回最后一个关键字块的位置。
    pos = 0
    # 否则，函数遍历modelName模型的关键字块列表，并检查每个关键字块的前缀是否与blockPrefix匹配。
    for block in mdb.models[modelName].keywordBlock.sieBlocks:
        if block[0:len(blockPrefix)].lower()==blockPrefix.lower():
            return pos
        pos=pos+1
        # 如果找到了匹配的关键字块，则返回其位置。
        # 如果没有找到匹配的关键字块，则返回-1。
    return -1

这个函数可以用于在Abaqus模型中自动查找特定类型的关键字块，例如材料定义、单元定义、荷载定义等等。通过使用这个函数，Python脚本可以自动从模型中提取需要的信息，并进行后续处理。

2.1 Sketch profile of truss - ReferencePoint / DatumPoint

这段代码用于在Abaqus模型中创建一个简单的桁架结构，并将其显示在Abaqus/CAE的视口中。

片段

# 第一行代码使用setValues()方法将当前视口的displayedObject属性设置为None，
# 从而清除当前视口中显示的对象。这是为了确保后续创建的模型能够正确显示在视口中。
session.viewports['Viewport: 1'].setValues(displayedObject=None)

# 接下来，创建一个名为Truss的新部件，并将其设置为三维可变形体。
p = mdb.models['Model-1'].Part(name='Truss', dimensionality=THREE_D, 
    type=DEFORMABLE_BODY)
# 然后，在部件上创建一个参考点，用于后续创建几何特征。
p.ReferencePoint(point=(0.0, 0.0, 0.0))
# 然后，获取Truss部件对象，
p = mdb.models['Model-1'].parts['Truss']
# 并将其设置为当前视口的显示对象。这使得后续创建的几何特征将直接显示在视口中。
session.viewports['Viewport: 1'].setValues(displayedObject=p)

# 接下来，使用DatumPointByOffset()方法在参考点上创建两个偏移点，用于创建桁架的两个端点。
d, r = p.datums, p.referencePoints
p.DatumPointByOffset(point=r[1], vector=(0.0, 1.0, 0.0))
p.DatumPointByOffset(point=r[1], vector=(8.0, 1.5, 0.9))
# 然后，使用DatumPlaneByThreePoints()方法在这三个点上创建一个平面，用于后续创建桁架的横杆。
p.DatumPlaneByThreePoints(point1=r[1], point2=d[3], point3=d[2])

# 最后，使用DatumAxisByPrincipalAxis()方法创建一个沿着Y轴方向的主轴，用于后续创建桁架的竖杆。
p.DatumAxisByPrincipalAxis(principalAxis=YAXIS)

# 最后一行代码使用fitView()方法将视口调整为适合于新创建的模型的大小和位置，从而确保整个模型在视口中完全可见。
session.viewports['Viewport: 1'].view.fitView()

总的来说，这段代码用于在Abaqus/CAE中创建并显示一个简单的桁架结构。它演示了如何使用Abaqus Python API在Python脚本中创建模型并将其显示在Abaqus/CAE的视口中。

执行结果

请添加图片描述

2.2 Sketch profile of truss - MakeSketch（创建草图+几何约束）

这段代码用于在Abaqus模型中创建一个桁架结构的草图，并将其转换为桁架的线条。

执行结果

请添加图片描述
在这里插入图片描述

片段

# 首先，创建一个草图变换（sketch transform），用于将草图平面和方向与桁架的参考平面和方向对齐。
t = p.MakeSketchTransform(sketchPlane=d[4], sketchUpEdge=d[5], 
    sketchPlaneSide=SIDE1, sketchOrientation=LEFT, origin=(0.0, 0.0, 0.0))
# 然后，在模型中创建一个规定的草图（ConstrainedSketch），并将其设置为超级叠加对象（primary object）。
s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__', 
    sheetSize=683.38, gridSpacing=17.08, transform=t)
g, v, d1, c = s.geometry, s.vertices, s.dimensions, s.constraints
s.setPrimaryObject(option=SUPERIMPOSE)

# 接下来，使用projectReferencesOntoSketch()方法将桁架参考几何体`投影`到草图上，以便在草图中创建桁架线条。
p = mdb.models['Model-1'].parts['Truss']
p.projectReferencesOntoSketch(sketch=s, filter=COPLANAR_EDGES)
session.viewports['Viewport: 1'].view.setValues(nearPlane=648.075, 
    farPlane=719.271, width=13.6266, height=9.28111, cameraPosition=(-71.5628, 
    0.978423, 679.645), cameraTarget=(4.83613, 0.978423, 0.544065))
# 然后，使用s.Line()方法创建桁架的线条，
s.Line(point1=(0.0, 0.0), point2=(8.05046582503149, 1.5))
# 并使用s.CoincidentConstraint()方法将线条约束到桁架参考几何体上。
s.CoincidentConstraint(entity1=v.findAt((0.0, 0.0)), entity2=g.findAt((0.0, 
    0.5)))

s.Line(point1=(8.05046582503149, 1.5), point2=(0.0, 1.0))

s.Line(point1=(0.0, 1.0), point2=(1.59409310185916, 0.297018794285658))
s.CoincidentConstraint(entity1=v.findAt((1.594093, 0.297019)), 
    entity2=g.findAt((4.025233, 0.75)))

s.Line(point1=(1.59409310185916, 0.297018794285658),
    point2=(2.30592731982451, 1.14321701190598))
s.CoincidentConstraint(entity1=v.findAt((2.305927, 1.143217)), 
    entity2=g.findAt((4.025233, 1.25)))

s.Line(point1=(2.30592731982451, 1.14321701190598),
    point2=(3.26033977276254, 0.607481575033539))
s.CoincidentConstraint(entity1=v.findAt((3.26034, 0.607482)),
    entity2=g.findAt((4.025233, 0.75)))

s.Line(point1=(3.26033977276254, 0.607481575033539),
    point2=(4.16525059699136, 1.25869624736747))
s.CoincidentConstraint(entity1=v.findAt((4.165251, 1.258696)), 
    entity2=g.findAt((4.025233, 1.25)))

s.Line(point1=(4.16525059699136, 1.25869624736747),
    point2=(4.95150583156061, 0.922587451305882))
s.CoincidentConstraint(entity1=v.findAt((4.951506, 0.922587)), 
    entity2=g.findAt((4.025233, 0.75)))
# 接下来，使用s.breakCurve()方法在线条上创建新的连接点，以便在草图中创建桁架的横杆和竖杆。
s.breakCurve(curve1=g.findAt((4.025233, 0.75)),
    point1=(0.733189206279801, 0.182644009590149),
    curve2=g.findAt((1.95001, 0.720118)),
    point2=(1.62787567272877, 0.433001518249512))

s.breakCurve(curve1=g.findAt((4.822279, 0.898509)),
    point1=(2.34362044857835, 0.415118813514709),
    curve2=g.findAt((2.783134, 0.875349)),
    point2=(3.22040910681461, 0.701241612434387))

s.breakCurve(curve1=g.findAt((5.655403, 1.053741)),
    point1=(4.04351950354929, 0.772772312164307),
    curve2=g.findAt((4.558378, 1.090642)),
    point2=(5.02767302451382, 0.95159912109375))

s.breakCurve(curve1=g.findAt((4.025233, 1.25)),
    point1=(1.55629884485765, 1.09466052055359),
    curve2=g.findAt((1.95001, 0.720118)),
    point2=(2.32572264036564, 1.02312982082367))

s.breakCurve(curve1=g.findAt((5.178197, 1.321609)),
    point1=(3.79300780849022, 1.23772192001343),
    curve2=g.findAt((3.712795, 0.933089)),
    point2=(4.168774592922, 1.18407392501831))
# 然后，使用s.VerticalDimension()方法和s.HorizontalDimension()方法创建桁架线条之间的水平和垂直尺寸。
s.VerticalDimension(vertex1=v.findAt((0.0, 1.0)),
    vertex2=v.findAt((0.0, 0.0)), 
    textPoint=(-0.304643334343144, 0.0216999053955078), value=1.0)
s.HorizontalDimension(vertex1=v.findAt((0.0, 0.0)),
    vertex2=v.findAt((8.050466, 1.5)),
    textPoint=(6.26233672422377, -0.443249702453613), value=8.05046582503149)
# 最后，使用s.ParallelConstraint()方法
# 和s.EqualLengthConstraint()方法对线条进行并行和等长约束。
s.ParallelConstraint(entity1=g.findAt((1.152964, 1.071609)), entity2=g.findAt((
    3.235589, 1.200957)))

s.ParallelConstraint(entity1=g.findAt((3.235589, 1.200957)), entity2=g.findAt((
    6.107858, 1.379348)))

s.ParallelConstraint(entity1=g.findAt((0.797047, 0.148509)), entity2=g.findAt((
    2.427216, 0.45225)))

s.ParallelConstraint(entity1=g.findAt((2.427216, 0.45225)), entity2=g.findAt((
    4.105923, 0.765035)))

s.ParallelConstraint(entity1=g.findAt((4.105923, 0.765035)), entity2=g.findAt((
    6.500986, 1.211294)))

s.EqualLengthConstraint(entity1=g.findAt((0.797047, 0.148509)), 
    entity2=g.findAt((2.427216, 0.45225)))

s.EqualLengthConstraint(entity1=g.findAt((2.39114, 0.445528)), 
    entity2=g.findAt((4.033769, 0.751591)))

s.EqualLengthConstraint(entity1=g.findAt((3.985233, 0.742547)), 
    entity2=g.findAt((6.416373, 1.195528)))

s.EqualLengthConstraint(entity1=g.findAt((1.152964, 1.071609)), 
    entity2=g.findAt((3.235589, 1.200957)))

s.EqualLengthConstraint(entity1=g.findAt((3.458891, 1.214826)), 
    entity2=g.findAt((6.33116, 1.393217)))
# 接下来，使用mdb.models['Model-1'].ConstrainedSketch()方法创建一个具有相同几何形状和约束的新草图。
mdb.models['Model-1'].ConstrainedSketch(name='Truss', objectToCopy=s)
# 然后，获取Truss部件对象，
p = mdb.models['Model-1'].parts['Truss']
d = p.datums
# 并使用p.Wire()方法将新草图转换为桁架的线条。
p.Wire(sketchPlane=d[4], sketchUpEdge=d[5], sketchPlaneSide=SIDE1, 
    sketchOrientation=LEFT, sketch=s)
# 最后，使用s.unsetPrimaryObject()方法将当前草图的超级叠加对象属性取消设置
s.unsetPrimaryObject()

这段代码用于在Abaqus/CAE中创建桁架结构的草图，并将其转换为桁架的线条。它演示了如何使用Abaqus Python API在Python脚本中创建模型和几何特征，并如何使用几何约束和操作对特征进行编辑和转换。

超级叠加对象（primary object）

超级叠加对象（primary object）是在Abaqus/CAE中用于创建草图、几何特征和模型的一种特殊对象。一个草图或几何特征可以被指定为超级叠加对象，这样它就可以与其他对象重叠并与其对齐，而不会影响其他对象的位置和形状。

在创建草图或几何特征时，可以使用setPrimaryObject()方法将其指定为超级叠加对象。一旦指定为超级叠加对象，该对象就会被放置在其他对象的顶部，并可以与其他对象重叠。在草图中，超级叠加对象通常用于创建几何特征；
在几何特征中，超级叠加对象通常用于创建其他几何特征。

在Abaqus/CAE中，超级叠加对象通常用于创建复杂的几何特征和模型。使用超级叠加对象可以避免几何特征之间的冲突和干扰，从而使几何特征更加容易编辑和修改。

projectReferencesOntoSketch()将几何引用对象（例如边、面和体）投影到草图平面

projectReferencesOntoSketch()方法用于将几何引用对象（例如边、面和体）投影到草图平面上，并在草图中创建相应的几何图形。下面是一个示例，演示如何使用projectReferencesOntoSketch()方法将一个立方体的侧面边投影到草图中，并在草图中创建相应的线条。

from abaqus import *
from abaqusConstants import *
from caeModules import *

# 创建模型、部件和草图
myModel = mdb.Model(name='myModel')
myPart = myModel.Part(name='myPart', dimensionality=THREE_D, type=DEFORMABLE_BODY)
mySketch = myPart.MakeSketch(name='mySketch', sheetSize=10.0)

# 创建立方体并获取其侧面边
myPart.Cube(center=(0,0,0), size=2.0)
sideEdge = myPart.edges.findAt((1.0, 0.0, 0.0))

# 将侧面边投影到草图中，并在草图中创建相应的线条
mySketch.projectReferencesOntoSketch(filter=COPLANAR_EDGES, 
    sketchPlane=myPart.faces[0], sketchUpEdge=None, sketchPlaneSide=SIDE1, sketchOrientation=RIGHT)
mySketch.Line(point1=(0.0,0.0), point2=(1.0,0.0))

# 创建模型视口并显示草图和几何对象
myViewport = session.Viewport(name='myViewport')
myViewport.setValues(displayedObject=myPart)
myViewport.partDisplay.setValues(sectionAssignments=ON)
myViewport.assemblyDisplay.setValues(sectionAssignments=ON)
myViewport.setValues(displayedObject=mySketch)
myViewport.view.fitView()

# 显示模型视口
myViewport.maximize()
myViewport.view.setProjection(projection=PARALLEL)
myViewport.view.setValues(nearPlane=10.0, farPlane=20.0, 
    width=10.0, height=10.0, cameraPosition=(10.0, 10.0, 10.0), 
    cameraTarget=(0.0, 0.0, 0.0))

在这个示例中，首先创建了一个模型、部件和草图。然后，使用Cube()方法在部件中创建一个立方体，并使用edges.findAt()方法获取立方体的侧面边。接下来，使用projectReferencesOntoSketch()方法将侧面边投影到草图中，并在草图中创建相应的线条。最后，创建一个模型视口并显示草图和几何对象。

需要注意的是，projectReferencesOntoSketch()方法需要指定投影的平面、投影的对象类型和投影的方向。在本示例中，投影的平面为立方体的第一个面，投影的对象类型为共面边，投影的方向为右侧。此外，需要注意的是，在投影完成后，需要手动在草图中创建相应的几何对象，如本示例中的线条。

2.3

执行结果

在这里插入图片描述
在这里插入图片描述

片段

del mdb.models['Model-1'].sketches['__profile__']

session.viewports['Viewport: 1'].view.fitView()

p = mdb.models['Model-1'].parts['Truss']
d, r = p.datums, p.referencePoints
p.DatumPointByOffset(point=d[2], vector=(0.0, 0.0, 2.0))
p.DatumPointByOffset(point=r[1], vector=(0.0, 0.0, 2.0))
p.DatumPointByOffset(point=d[3], vector=(0.0, 0.0, 0.2))
p.DatumPlaneByThreePoints(point1=d[8], point2=d[9], point3=d[7])

t = p.MakeSketchTransform(sketchPlane=d[10], sketchUpEdge=d[5], 
    sketchPlaneSide=SIDE1, sketchOrientation=LEFT, origin=(4.122203, 0.75, 
    1.536252))
s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__', 
    sheetSize=683.38, gridSpacing=17.08, transform=t)
g, v, d, c = s.geometry, s.vertices, s.dimensions, s.constraints
s.setPrimaryObject(option=SUPERIMPOSE)
p.projectReferencesOntoSketch(sketch=s, filter=COPLANAR_EDGES)
s.retrieveSketch(sketch=mdb.models['Model-1'].sketches['Truss'])
s.move(vector=(-4.14820681508444, -0.75), objectList=(g.findAt((0.0, 0.5)), 
    g.findAt((1.006308, 0.6875)), g.findAt((2.348053, 0.770833)), g.findAt((
    3.354361, 0.958333)), g.findAt((4.696105, 1.041667)), g.findAt((5.702413, 
    1.229167)), g.findAt((1.006308, 0.1875)), g.findAt((3.018925, 0.5625)), 
    g.findAt((5.031541, 0.9375)), g.findAt((7.044158, 1.3125)), g.findAt((
    1.341744, 1.083333)), g.findAt((6.708722, 1.416667)), g.findAt((4.025233, 
    1.25)), v.findAt((8.050466, 1.5)), v.findAt((0.0, 1.0))))
d = p.datums
p.Wire(sketchPlane=d[10], sketchUpEdge=d[5], sketchPlaneSide=SIDE1, 
    sketchOrientation=LEFT, sketch=s)
s.unsetPrimaryObject()
del mdb.models['Model-1'].sketches['__profile__']

解析

这段代码是用于在Abaqus/CAE中创建桁架结构的示例。下面是对每行代码的解释：

del mdb.models['Model-1'].sketches['__profile__']

删除原有的草图。

session.viewports['Viewport: 1'].view.fitView()

将视口中的模型缩放以适应视口大小。

p = mdb.models['Model-1'].parts['Truss']
d, r = p.datums, p.referencePoints
p.DatumPointByOffset(point=d[2], vector=(0.0, 0.0, 2.0))
p.DatumPointByOffset(point=r[1], vector=(0.0, 0.0, 2.0))
p.DatumPointByOffset(point=d[3], vector=(0.0, 0.0, 0.2))
p.DatumPlaneByThreePoints(point1=d[8], point2=d[9], point3=d[7])

获取Truss部件对象，并在该部件中创建三个偏移点和一个三点平面。

t = p.MakeSketchTransform(sketchPlane=d[10], sketchUpEdge=d[5], 
    sketchPlaneSide=SIDE1, sketchOrientation=LEFT, origin=(4.这行代码不完整，可能是由于输入时意外按下了回车键。根据上下文推测，这行代码的完整形式应该是：


s = mdb.models['Model-1'].ConstrainedSketch(name='__profile__', 
    sheetSize=683.38, gridSpacing=17.08, transform=t)

创建一个名为__profile__的约束草图，并将其命名为s。该草图的大小为sheetSize=683.38，网格间隔为gridSpacing=17.08，变换对象为t。

g, v, d, c = s.geometry, s.vertices, s.dimensions, s.constraints
s.setPrimaryObject(option=SUPERIMPOSE)
p.projectReferencesOntoSketch(sketch=s, filter=COPLANAR_EDGES)
s.retrieveSketch(sketch=mdb.models['Model-1'].sketches['Truss'])
s.move(vector=(-4.14820681508444, -0.75), objectList=(g.findAt((0.0, 0.5)), 
    g.findAt((1.006308, 0.6875)), g.findAt((2.348053, 0.770833)), g.findAt((
    3.354361, 0.958333)), g.findAt((4.696105, 1.041667)), g.findAt((5.702413, 
    1.229167)), g.findAt((1.006308, 0.1875)), g.findAt((3.018925, 0.5625)), 
    g.findAt((5.031541, 0.9375)), g.findAt((7.044158, 1.3125)), g.findAt((
    1.341744, 1.083333)), g.findAt((6.708722, 1.416667)), g.findAt((4.025233, 
    1.25)), v.findAt((8.050466, 1.5)), v.findAt((0.0, 1.0))))

获取约束草图s中的几何、顶点、尺寸和约束，并将草图s指定为超级叠加对象。然后，使用projectReferencesOntoSketch()方法将部件中的几何对象投影到草图s中。接下来，使用retrieveSketch()方法将Truss部件中的草图复制到草图s中，然后使用move()方法移动草图中的几何对象以与部件中的几何对象对齐。最后，将草图s中的几何对象用于创建部件中的线。

d = p.datums
p.Wire(sketchPlane=d[10], sketchUpEdge=d[5], sketchPlaneSide=SIDE1, 
    sketchOrientation=LEFT, sketch=s)

获取Truss部件中的所有基准面和基准轴，并使用草图s中的几何对象创建一个线框架。

s.unsetPrimaryObject()
del mdb.models['Model-1'].sketches['__profile__']

将草图s的超级叠加对象属性取消，然后删除草图。

3 dummy part

片段

##
##  dummy part
##
p = mdb.models['Model-1'].Part(name='Truss-all', 
    objectToCopy=mdb.models['Model-1'].parts['Truss'])
session.viewports['Viewport: 1'].setValues(displayedObject=p)
v = p.vertices
p.WirePolyLine(points=((v.findAt(coordinates=(2.0, 0.375, 1.775)), v.findAt(
    coordinates=(2.0, 0.375, 0.225))), (v.findAt(coordinates=(2.0, 0.375, 
    0.225)), v.findAt(coordinates=(2.666667, 1.166667, 1.7))), (v.findAt(
    coordinates=(2.666667, 1.166667, 1.7)), v.findAt(coordinates=(2.666667, 
    1.166667, 0.3))), (v.findAt(coordinates=(4.0, 0.75, 1.55)), v.findAt(
    coordinates=(4.0, 0.75, 0.45))), (v.findAt(coordinates=(4.0, 0.75, 0.45)), 
    v.findAt(coordinates=(5.333333, 1.333333, 1.4))), (v.findAt(coordinates=(
    5.333333, 1.333333, 1.4)), v.findAt(coordinates=(5.333333, 1.333333, 
    0.6))), (v.findAt(coordinates=(5.333333, 1.333333, 0.6)), v.findAt(
    coordinates=(6.0, 1.125, 1.325))), (v.findAt(coordinates=(6.0, 1.125, 
    1.325)), v.findAt(coordinates=(6.0, 1.125, 0.675)))), mergeType=IMPRINT, 
    meshable=ON)

这段代码创建了一个名为Truss-all的新部件，并从现有的名为Truss的部件中复制了所有对象。然后，使用WirePolyLine()方法创建了一个线框架，该线框架由一系列点组成，这些点是通过findAt()方法从Truss-all部件中的顶点中选择的。最后，使用mergeType=IMPRINT将新的线框架与Truss-all部件合并，并设置meshable=ON以使该部件可网格化。

需要注意的是，这段代码中的点坐标是在Truss-all部件的局部坐标系中指定的。此外，使用WirePolyLine()方法创建的线框架的起点和终点是通过相邻的点之间的线段自动确定的。因此，代码中指定的点的顺序非常重要。

hmywillstronger
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
python参数化建模加工图_基于Python的ABAQUS层压板参数化建模
weixin_30026331的博客
12-23 818
唐维　康泽毓　杨婷　曾凤　蒋莉摘要：为了提高层压板在ABAQUS仿真中建模的效率与准确性，提出利用Python语言对ABAQUS二次开发进行层压板参数化建模的方法。基于ABAQUS有限元软件，采用Python编写脚本文件对ABAQUS内核文件直接操作，准确而高效地完成层压板的多层材料复合建模、材料属性定义、截面创建及截面指派等操作。结果表明：利用Python脚本进行层压板参数建模的方法能快速准确地...
python 参数化_[转载]Abaqus交互式参数化Python建模
weixin_39610468的博客
12-03 1047
Abaqus交互式参数化Python建模与计算1 概述Abaqus的脚本接口有几种方式，前一次讨论过利用Plug-in插件的方式，这次采用交互式，将操作者设置的参数反馈到Python脚本文件中，再通过Abaqus的内核运行，完成有限元分析过程。、完成交互式参数化用到的主要函数是getInput()和getInputs()，也有提示信息的getWarningReply()。本次用到的模型例子如图1。...
基于python脚本的参数化建模_Python在ABAQUS中
weixin_39939303的博客
12-03 985
Python在ABAQUS中所属分类：其他开发工具：Python文件大小：17325KB下载次数：0上传日期：2020-11-25 11:47:17上 传 者：qwe12334说明：1、 用Python脚本实现Abaqus参数化建模在Abaqus中运行Python语言编写的代码可以实现在CAE用户界面中能够实现的全部功能，包括建模，定义材料属性，定义计算步，定义接触和约束，划分网格，提交计算任...
Python Scripts For ABAQUS: Learn By Example (全书完整，下载地址)
01-25
这是完全版本的英文书，共747页，182M，txt文件中是百度云的链接地址，如果失效请留言并发站内消息
ABAQUS参数化前处理程序
05-20
基于Python的ABAQUS参数建模代码，针对的建模对象为热防护系统ITPS结构
example1.py_pythonabaqus_python_有限元_ABAQUS_
10-04
本程序以abaqus构建模块为例，采用Python语言进行编写，能够实现自定义模型属性如尺寸，如材料属性：杨氏模量等基本信息。避免重复繁琐修改设置
有限元仿真常用材料参数+Abaqus材料库插件
03-12
内容包含500多种有限元仿真的常见材料参数和这些材料的abaqus材料库插件
MPC_Cube.rar_ABAQUS 多点约束_MPC Python_twc_有限元
07-14
用于有限元abaqus多点约束的程序，采用Python实现
基于ABAQUS乳化液泵曲轴应力有限元分析
07-01
利用ABAQUS6.9有限元软件,以乳化液泵曲轴为研究对象,运用有限元分析软件研究曲轴的应力和变形情况,确定了曲轴的最危险相位和最大应力值。首先介绍了曲轴的网格处理方法,然后对曲轴的约束和加载作了必要的描述,最后...
多SHEET页的EXCEL文件批量合并
Wily的博客
10-13 698
前段时间工作中遇到需要将多个excel合并，且每个excel都有多个sheet页 在CSDN也没搜到特别简洁的代码，其实就两个循环的事情 不过还好，站在巨人的肩膀上看的远，就集各家所长，为己所用 顺带写了带图形界面的，顺带用PyQt5打了个包，上代码 import sys from PyQt5 import QtCore, QtWidgets, QtGui from PyQt5.QtWidgets import * import pandas as pd import os import xl
使用Python调用Abaqus交互命令
05-08
使用Python调用Abaqus交互命令，替代图形交互界面，ABAQUS官方帮助文档，侵删。
一小时学会abaqus脚本
03-07
一小时学会ABAQUS脚本，快速学会如何写Python脚本文件
abaqus python二次开发攻略_Abaqus二次开发Python脚本二次开发
weixin_39580715的博客
11-20 756
在上一篇博文中简要介绍了Abaqus中FORTRAN子程序二次开发,那么这次将对Abaqus的Python脚本二次开发进行概述。 就像在上一篇博文中提到的，基于Python的脚本开发又可以细分为如下三大类：1)通过Python脚本实现Abaqus参数化建模；2)通过Python脚本实现用户定制化后处理；3)应用Python语言通过FoxGUI Toolkit编写GUI(可视...
abaqus中python怎么建立参考点_ABAQUS中用Python调取（多个）参考点
weixin_39704246的博客
12-10 1350
ABAQUS中建立复杂模型，尤其是复杂接触或者复杂约束时，往往采用参数化更为高效，这些问题中常常会建立为数不少的参考点，对这些参考点的读取和调用是不可避免地，但ABAQUS模型中的Python对象众多，且各适用于不同的函数，导致常常出现如下错误：TypeError: region; found Feature, expecting Region本文讨论的问题也是基于此类报错。下面先看看笔者遇到的问...
python项目案例开发详解_基于Python的Abaqus二次开发实例讲解
weixin_39627481的博客
11-30 530
http://www.mechbbs.com第1页共11页基于Python的Abaqus二次开发实例讲解（asian58 2013.6.26）基于Python的Abaqus的二次开发便捷之处在于：1、所有的代码均可以先在Abaqus\CAE中操作一遍后再通过rp文件读取，然后再在此基础上进行相应的修改；2、Python是一种解释性语言，读起来非常清晰，因此在修改程序的过程中，不存在程序难以理解的问...
python脚本实例-Abaqus利用Python脚本建模实例
weixin_37988176的博客
10-30 3512
Abaqus利用Python脚本建模实例1 概述通过Python编写的命令能够通过Abaqus的内核执行，编写Python脚本快速建模使Abaqus高级用户经常使用的功能之一。本次以一个实例，说明通过Python脚本语言进行Abaqus有限元分析的过程，模型如图1所示。图1模型2 过程（1）建模：代码如下：from abaqus import* #引入模块fromabaqusConstants i...
曲面偏微分方程：参数化有限元方法
LSEC小陆的博客
11-06 1640
曲面偏微分方程：参数化有限元方法 前面介绍的P\mathbf{P}P和Pd\mathbf{Pd}Pd，及其对应的同参等值延伸及投影自然延伸，对于曲面上有限元方法的理论分析起着至关重要的作用。 利普希茨参数曲面上的FEM 利普希茨参数化曲面 因为同参映射P\mathbf{P}P的双利普希茨性，存在一个常数LLL，使得  (64) L−1∣x1−x2∣≤∣x~1−x~2∣≤L∣x1...
使用python进行ABAQUS的二次开发的简要说明（by Young 2017.06.27）
热门推荐
扬子江畔的小驿站
08-22 5万+
（所有用词以英文为准，翻译仅供参考） 一、abaqus二次开发总述： 首先最重要的知识点需要明确，abaqus在求解核心（Solver/ Kernel）和图形用户界面（GUI）之间使用的交互语言天然就是python，因此使用python进行abaqus二次开发是十分自然的选择（当然你也可以用C++，但是鉴于python所拥有的各类开源库函数的优势，python应当是二次开发的首选）。abaqu...
abaqus python建模_ABAQUS切削快速建模python程序
weixin_34080081的博客
01-26 1210
1 #-*- coding: mbcs -*-2 #3 #Abaqus/CAE Release 6.14-4 replay file4 #Internal Version: 2015_06_12-04.41.13 1350795 #Run by Administrator on Wed Apr 12 08:41:02 20176 #78 #from driverUtils import execu...
python scripts for abaqus learn by example
最新发布
09-25
Abaqus是一种用于有限元分析的强大软件，而Python是一种易学易用的编程语言，可以与Abaqus结合使用。这本书通过实际的案例示范，帮助读者了解如何使用Python编写Abaqus脚本。 这本书首先简要介绍了Abaqus的基本知识...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

hmywillstronger

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值