"""
Script for constructing the cylinder-cam mechanism model in ABAQUS/CAE for
Example Problem 4.1.6 from ABAQUS Example Problems Manual.
The script creates an ABAQUS/Explicit
model that can be submitted for analysis.

This example illustrates the use of connector elements to model a
cylinder-cam mechanism. The script reads an ACIS sat file (cylcammech.sat)
for constructing the display body of cylinder.

USAGE: ABAQUS/CAE-> File-> Run Script

"""

# connector examples
# cylinder cam mechanicsm
#
# model

from abaqus import *
import testUtils
testUtils.setBackwardCompatibility()
from abaqusConstants import *
from connectorBehavior import *
from caeModules import *
import regionToolset

# Create the model database.
#
Mdb()

myModel = mdb.models['Model-1']
vp=session.viewports[session.currentViewportName]

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Create the parts.
# Create a reference point on each part.
# Create a display name for the part and
# Display it in the current viewport.

# Create part 'track', assign reference pt.
#
track = myModel.Part(name='track', dimensionality=THREE_D,
    type=DISCRETE_RIGID_SURFACE)
track.ReferencePoint(point=(0.0, 0.0, 0.0))
partTrack = myModel.parts['track']
vp.setValues(displayedObject=partTrack)

# Create part 'pinTailRIGID', assign reference pt.
#
pinTailRIGID = myModel.Part(name='pinTailRIGID', dimensionality=THREE_D,
    type=DISCRETE_RIGID_SURFACE)
pinTailRIGID.ReferencePoint(point=(0.0, 0.0, 0.0))
partPinTailRIGID = myModel.parts['pinTailRIGID']
vp.setValues(displayedObject=partPinTailRIGID)

# Create part 'pinHeadRIGID', assign reference pt.
#
pinHeadRIGID = myModel.Part(name='pinHeadRIGID', dimensionality=THREE_D,
    type=DISCRETE_RIGID_SURFACE)
pinHeadRIGID.ReferencePoint(point=(3.0, 0.0, 0.0))
partPinHeadRIGID = myModel.parts['pinHeadRIGID']
vp.setValues(displayedObject=partPinHeadRIGID)

# Create part 'CylCenter', assign reference pt.
#
cylCenter = myModel.Part(name='CylCenter', dimensionality=THREE_D,
    type=DISCRETE_RIGID_SURFACE)
cylCenter.ReferencePoint(point=(3.5, 0.0, 0.0))
partCylCenter = myModel.parts['CylCenter']
vp.setValues(displayedObject=partCylCenter)

# Create part 'CylBottom', assign reference pt.
#
cylBottom = myModel.Part(name='CylBottom', dimensionality=THREE_D,
                         type=DISCRETE_RIGID_SURFACE)
cylBottom.ReferencePoint(point=(3.5, 0.0, 2.0))
partCylBottom = myModel.parts['CylBottom']
vp.setValues(displayedObject=partCylBottom)

refPtPartCylBottom = partCylBottom.referencePoints
refPointCylBottom = (refPtPartCylBottom[1], )

#Create mass inertia at refPts of cylinder bottom
#
region = regionToolset.Region(referencePoints=refPointCylBottom)
partCylBottom.engineeringFeatures.PointMassInertia(
    name='mass_zero', region=region, mass=1e-05, i11=1e-06,
    i22=1e-06, i33=1e-06, alpha=0.0, composite=0.0)

pinTailRIGID_refPts = partPinTailRIGID.referencePoints
refPointPinTail = (pinTailRIGID_refPts[1], )

#Create mass inertia at refPts of pinTailRIGID
#
region = regionToolset.Region(referencePoints=refPointPinTail)
partPinTailRIGID.engineeringFeatures.PointMassInertia(
    name='mass_pin', region=region, mass=0.00777025,
    i11=1e-05, i22=1e-05, i33=1e-05, alpha=0.0, composite=0.0)

refPoints = partTrack.referencePoints
refPointTrack = (refPoints[1], )

#Create mass inertia at refPts of partTrack
#
region = regionToolset.Region(referencePoints=refPointTrack)
partTrack.engineeringFeatures.PointMassInertia(
    name='mass_zero', region=region, mass=1e-05, i11=1e-06,
    i22=1e-06, i33=1e-06, alpha=0.0, composite=0.0)

# Create mass inertia at refPts of partCylCenter
#
refPoints = partCylCenter.referencePoints
refPointCylCenter = (refPoints[1], )

region = regionToolset.Region(referencePoints=refPointCylCenter)
partCylCenter.engineeringFeatures.PointMassInertia(
    name='mass_zero', region=region, mass=1e-05, i11=1e-06,
    i22=1e-06, i33=1e-06, alpha=0.0, composite=0.0)

# Create mass inertia for refPts of partPinHeadRIGID
#
refPt = partPinHeadRIGID.referencePoints
refPointPinHead=(refPt[1], )

region = regionToolset.Region(referencePoints=refPointPinHead)
partPinHeadRIGID.engineeringFeatures.PointMassInertia(
    name='mass_zero', region=region, mass=1e-05, i11=1e-06,
    i22=1e-06, i33=1e-06, alpha=0.0, composite=0.0)


#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Create instances
#

myAssembly = myModel.rootAssembly
vp.setValues(displayedObject=myAssembly)
myAssembly.DatumCsysByDefault(CARTESIAN)
myAssembly.Instance(name='CylBottom-1', part=cylBottom, dependent=OFF)
myAssembly.Instance(name='CylCenter-1', part=cylCenter, dependent=OFF)
myAssembly.Instance(name='pinHeadRIGID-1', part=pinHeadRIGID, dependent=OFF)
myAssembly.Instance(name='pinTailRIGID-1', part=pinTailRIGID, dependent=OFF)
myAssembly.Instance(name='track-1', part=track, dependent=OFF)
vp.view.setValues(width=0.25593, height=0.16361,
    viewOffsetX=-0.0043824, viewOffsetY=0.15046)
vp.view.fitView()

#Create a dynamic explicit step
#
myModel.ExplicitDynamicsStep(name='Step-1', previous='Initial',
    timePeriod=4.0, timeIncrementationMethod=FIXED_USER_DEFINED_INC,
    userDefinedInc=0.0001, massScaling=PREVIOUS_STEP)

# Define Connector section
#
myModel.ConnectorSection(name='ConnProp-1', assembledType=BEAM,
    translationalType=NONE, rotationalType=NONE)
point1 = myAssembly.instances['pinTailRIGID-1'].referencePoints[1]
point2 = myAssembly.instances['pinHeadRIGID-1'].referencePoints[1]
edge = myAssembly.WirePolyLine(points=((point1, point2), ), mergeWire=OFF,
                               meshable=OFF)
myAssembly.Set(name='TailHead-conn', edges=myAssembly.getFeatureEdges(edge.name))
csa = myAssembly.SectionAssignment(region=myAssembly.sets['TailHead-conn'],
                                   sectionName='ConnProp-1')
myAssembly.ConnectorOrientation(region=csa.getSet())

point1 = myAssembly.instances['CylCenter-1'].referencePoints[1]
point2 = myAssembly.instances['CylBottom-1'].referencePoints[1]
edge = myAssembly.WirePolyLine(points=((point1, point2), ), mergeWire=OFF,
                               meshable=OFF)
myAssembly.Set(name='center-bottom-conn', edges=myAssembly.getFeatureEdges(edge.name))
csa = myAssembly.SectionAssignment(region=myAssembly.sets['center-bottom-conn'],
                                   sectionName='ConnProp-1')
myAssembly.ConnectorOrientation(region=csa.getSet())

#Create connector property 2 with damping
#
damping = ConnectorDamping(components=(1, ), table=((1.0, ), ))
myModel.ConnectorSection(name='ConnProp-2',
    translationalType=SLOT, rotationalType=ALIGN, behaviorOptions=(damping,))

myAssembly.DatumCsysByThreePoints(name='Datum csys-2', coordSysType=CARTESIAN,
                                  origin=(0.0, 0.0, 0.0), point1=(0.0, 0.0, 1.0),
                                  point2=(1.0, 0.0, 0.0))
myAssembly.DatumCsysByThreePoints(name='Datum csys-3', coordSysType=CARTESIAN,
                                  origin=(3.5, 0.0, 0.0), point1=(3.5, 0.7, -0.7),
                                  point2=(3.0, 0.0, 0.0))

point1 = myAssembly.instances['track-1'].referencePoints[1]
point2 = myAssembly.instances['pinTailRIGID-1'].referencePoints[1]
orient1 = myAssembly.datums[16]
edge = myAssembly.WirePolyLine(points=((point1, point2), ), mergeWire=OFF, meshable=OFF)
myAssembly.Set(name='track-conn', edges=myAssembly.getFeatureEdges(edge.name))
csa = myAssembly.SectionAssignment(region=myAssembly.sets['track-conn'],
                                   sectionName='ConnProp-2')
myAssembly.ConnectorOrientation(region=csa.getSet(), localCsys1=orient1)

cstop = ConnectorStop(components=(1, ), minMotion=-0.03536, maxMotion=0.03536)
myModel.ConnectorSection(name='ConnProp-3', assembledType=NONE,
    translationalType=CARTESIAN, rotationalType=NONE, behaviorOptions=(cstop,))
point1 = myAssembly.instances['CylCenter-1'].referencePoints[1]
point2 = myAssembly.instances['pinHeadRIGID-1'].referencePoints[1]
orient1 = myAssembly.datums[17]
edge = myAssembly.WirePolyLine(points=((point1, point2), ), mergeWire=OFF, meshable=OFF)
myAssembly.Set(name='slot-conn', edges=myAssembly.getFeatureEdges(edge.name))
csa = myAssembly.SectionAssignment(region=myAssembly.sets['slot-conn'],
                                   sectionName='ConnProp-3')
myAssembly.ConnectorOrientation(region=csa.getSet(), localCsys1=orient1)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Create Boundary conditions
#
refpts = (myAssembly.instances['track-1'].referencePoints[1], )
region = myAssembly.Set(referencePoints=refpts, name='track')
myModel.DisplacementBC(name='BC-1', createStepName='Step-1',
    region=region, u1=0.0, u2=0.0, u3=0.0, ur1=0.0, ur2=0.0, ur3=0.0,
    amplitude=UNSET, fixed=OFF, distributionType=UNIFORM, localCsys=None)

refpts = (myAssembly.instances['CylBottom-1'].referencePoints[1], )
region = regionToolset.Region(referencePoints=refpts)
myModel.VelocityBC(name='BC-2', createStepName='Step-1',
    region=region, v1=0.0, v2=0.0, v3=0.0, vr1=0.0, vr2=0.0, vr3=3.1415926,
    amplitude=UNSET, localCsys=None, distributionType=UNIFORM)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Creating pin
#
sketch4 = myModel.Sketch(name='__profile__', sheetSize=10.0)
geomsketch4, vertsketch4, dimsketch4 = sketch4.geometry, sketch4.vertices, sketch4.dimensions
sketch4.sketchOptions.setValues(sheetSize=10.0, gridSpacing=0.2, grid=ON,
    gridFrequency=2, constructionGeometry=ON, dimensionTextHeight=0.2,
    decimalPlaces=2)
sketch4.setPrimaryObject(option=STANDALONE)
sketch4.ObliqueConstructionLine(point1=(0.0, -5.0), point2=(0.0, 5.0))
vp.view.fitView()
myModel.sketches['__profile__'].sketchOptions.setValues(
    sheetSize=10.0, gridSpacing=0.05, grid=ON, gridFrequency=2,
    constructionGeometry=ON, dimensionTextHeight=0.2, decimalPlaces=2,
    gridSnap=ON, preselection=ON)
sketch4.Spot(point=(0.0, -0.25))
sketch4.Spot(point=(0.0, -0.5))
sketch4.CircleByCenterPerimeter(center=(0.0, -0.5), point1=(0.0, -0.25))

sketch4.Spot(point=(0.05, -3.0))
sketch4.delete(objectList=(geomsketch4[11], ))
sketch4.Spot(point=(0.0, -3.0))
sketch4.Spot(point=(0.3, -3.0))
sketch4.Spot(point=(0.2, -0.7))
sketch4.Line(point1=(0.0, -3.0), point2=(0.2, -3.0))
sketch4.Line(point1=(0.2, -3.0), point2=(0.2, -0.7))
sketch4.delete(objectList=(geomsketch4[9], ))
sketch4.ArcByCenterEnds(center=(0.0, -0.5), point1=(0.0, -0.25), point2=(0.2, -0.7))
sketch4.undo()
sketch4.ArcByCenterEnds(center=(0.0, -0.5), point1=(0.0, -0.25), point2=(0.2, -0.7))
sketch4.Spot(point=(0.176776695296637, -0.676776695296637))
sketch4.Line(point1=(0.176776695296637, -0.676776695296637), point2=(0.25, -0.8))
sketch4.undo()
sketch4.undo()
sketch4.delete(objectList=(geomsketch4[20], ))
sketch4.delete(objectList=(geomsketch4[29], ))
sketch4.delete(objectList=(geomsketch4[27], geomsketch4[27]))
sketch4.delete(objectList=(geomsketch4[17], ))
sketch4.Spot(point=(0.176776695296637, -0.676776695296637))
sketch4.Line(point1=(0.176776695296637, -0.676776695296637), point2=(0.2, -3.0))
sketch4.unsetPrimaryObject()
#/# bug in old sketches convert and then do revolve
myModel.convertAllSketches()
sketch4 = myModel.sketches['__profile__']

pinHead = myModel.Part(name='pinHead', dimensionality=THREE_D,
    type=DEFORMABLE_BODY)
partPinHead = myModel.parts['pinHead']


partPinHead.BaseShellRevolve(sketch=sketch4, angle=360.0, flipRevolveDirection=OFF)


del myModel.sketches['__profile__']


instPinHead = myAssembly.Instance(name='pinHead-1', part=partPinHead, dependent=OFF)
instPinHead = myAssembly.instances['pinHead-1']

instPinHead.rotateAboutAxis(axisPoint=(0.0, 0.0, 0.0), axisDirection=(0.0, 0.0, 1.0),
                            angle=90.0)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Create deformable cylinder part
#
sketchCyl = myModel.Sketch(name='__profile__', sheetSize=2.0)
geomCyl, vertCyl, dimCyl = sketchCyl.geometry, sketchCyl.vertices, sketchCyl.dimensions
sketchCyl.sketchOptions.setValues(sheetSize=2.0, gridSpacing=0.05, grid=ON,
    gridFrequency=2, constructionGeometry=ON, dimensionTextHeight=0.05,
    decimalPlaces=2)
sketchCyl.setPrimaryObject(option=STANDALONE)
sketchCyl.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.5, 0.0))
cyl = myModel.Part(name='cylinder', dimensionality=THREE_D,
    type=DEFORMABLE_BODY)
cyl.BaseSolidExtrude(sketch=sketchCyl, depth=3.0)
sketchCyl.unsetPrimaryObject()
vp.setValues(displayedObject=cyl)
del myModel.sketches['__profile__']

partCyl = myModel.parts['cylinder']
partCyl.DatumPointByCoordinate(coords=(0.0, 0.0, 1.5))
partCyl.DatumPointByCoordinate(coords=(0.0, 0.5, 2.0))
datumCyl = partCyl.datums
partCyl.DatumAxisByTwoPoint(point1=datumCyl[2], point2=datumCyl[3])
partCyl.DatumPlaneByPointNormal(point=datumCyl[2], normal=datumCyl[4])

cellsCyl = partCyl.cells
cells = (cellsCyl.findAt((0.178993, -0.109401, 0.0), ), )
partCyl.PartitionCellByDatumPlane(datumPlane=datumCyl[5], cells=cells)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Create cylinder from imported .sat sketch
#
acis = mdb.openAcis('cylcammech.sat')
myModel.SketchFromGeometryFile(name='cylcammech', geometryFile=acis)
edgesCyl= partCyl.edges
trans = partCyl.MakeSketchTransform(sketchPlane=datumCyl[5],
                                    sketchUpEdge=edgesCyl.findAt((0.0, 0.5, 0.0), ),
                                    sketchPlaneSide=SIDE1, sketchOrientation=RIGHT,
                                    origin=(0.0, 0.0, 1.5))

sketchSweep = myModel.Sketch(name='__sweep__', sheetSize=2.0,
                             gridSpacing=0.05, transform=trans)
geomsketchSweep, vertsketchSweep, dimsketchSweep = sketchSweep.geometry, sketchSweep.vertices,sketchSweep.dimensions
sketchSweep.sketchOptions.setValues(sheetSize=2.0, gridSpacing=0.05, grid=ON,
                                    gridFrequency=2, constructionGeometry=ON,
                                    dimensionTextHeight=0.05,decimalPlaces=2)
sketchSweep.setPrimaryObject(option=SUPERIMPOSE)
partCyl.projectReferencesOntoSketch(sketch=sketchSweep, filter=COPLANAR_EDGES)
refGeom, refVert = sketchSweep.referenceGeometry, sketchSweep.referenceVertices
sketchSweep.retrieveSketch(sketch=myModel.sketches['cylcammech'])

sketchSweep.unsetPrimaryObject()

sketch1 = myModel.Sketch(name='__profile__', sheetSize=2.0,
                         transform=(1.0, 0.0, 0.0, 0.0, 0.707106781186548,
                                    0.707106781186548, 0.0, -0.707106781186548,
                                    0.707106781186548, 0.5, 3.06151588455594e-17, 1.5)
                         )
geomsketch1, vertsketch1, dimsketch1 = sketch1.geometry, sketch1.vertices, sketch1.dimensions
sketch1.sketchOptions.setValues(sheetSize=2.0, gridSpacing=0.05, grid=ON,
                                gridFrequency=2, constructionGeometry=ON,
                                dimensionTextHeight=0.05, decimalPlaces=2)
sketch1.setPrimaryObject(option=SUPERIMPOSE)
sketch1.ObliqueConstructionLine(point1=(-1.0, 0.0), point2=(1.0, 0.0))
sketch1.ObliqueConstructionLine(point1=(0.0, -1.0), point2=(0.0, 1.0))

partCyl.projectReferencesOntoSketch(sketch=sketch1, filter=COPLANAR_EDGES)
refGeomsketch1, refVertsketch1 = sketch1.referenceGeometry, sketch1.referenceVertices
sketch1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(-0.3, 0.0))
sketch1.constraintReferences(vertex1=refVertsketch1.findAt((0.0, 0.0), 1))

partCyl.CutSweep(pathPlane=datumCyl[5], pathUpEdge=edgesCyl.findAt((0.0, 0.5, 0.0), ),
                 sketchUpEdge=edgesCyl.findAt((0.0, 0.5, 0.0), ), pathOrientation=RIGHT,
                 path=sketchSweep, sketchOrientation=RIGHT, sketch=sketch1)
sketch1.unsetPrimaryObject()

vp.setValues(displayedObject=myAssembly)
myAssembly.DatumCsysByDefault(CARTESIAN)
myAssembly.Instance(name='cylinder-1', part=partCyl, dependent=OFF)


instCyl = myAssembly.instances['cylinder-1']
instCyl.translate(vector=(0.0, 0.0, -1.5))

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Creating pin tail
#
sketch5 = myModel.Sketch(name='__profile__', sheetSize=10.0)
geomsketch5, vertsketch5, dimsketch5 = sketch5.geometry, sketch5.vertices, sketch5.dimensions
sketch5.sketchOptions.setValues(sheetSize=10.0, gridSpacing=0.2, grid=ON,
    gridFrequency=2, constructionGeometry=ON, dimensionTextHeight=0.2,
    decimalPlaces=2)
sketch5.setPrimaryObject(option=STANDALONE)
sketch5.Spot(point=(0.0, -3.0))
sketch5.Line(point1=(0.0, -3.0), point2=(0.4, -3.0))
sketch5.Line(point1=(0.4, -3.0), point2=(0.4, -3.8))
sketch5.Line(point1=(0.4, -3.8), point2=(-0.4, -3.8))
sketch5.Line(point1=(-0.4, -3.8), point2=(-0.4, -3.0))
sketch5.Line(point1=(-0.4, -3.0), point2=(0.0, -3.0))

pinTail = myModel.Part(name='pinTail', dimensionality=THREE_D,
                       type=DEFORMABLE_BODY)
pinTail.BaseSolidExtrude(sketch=sketch5, depth=0.8)
sketch5.unsetPrimaryObject()
del myModel.sketches['__profile__']

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Create material and section definitions
#
mat1 = myModel.Material('Material-1')
mat1.Elastic(table=((1.0, 0.0), ))
mat1.Density(table=((1e-05, ), ))

myModel.HomogeneousSolidSection(name='Section-1', material='Material-1',
                                thickness=1.0)
partCyl.SectionAssignment(region=region, sectionName='Section-1')

pinTailCells = pinTail.cells
cells = pinTailCells.findAt(((-0.133333, -3.8, 0.533333), ), )
region = regionToolset.Region(cells=cells)

pinTail.SectionAssignment(region=region, sectionName='Section-1')
vp.setValues(displayedObject=myAssembly)

instPinTail = myAssembly.Instance(name='pinTail-1', part=pinTail,
                                  dependent=OFF)
instPinTail.translate(vector=(-3.0, 0.0, 0.0))
instPinTail.translate(vector=(3.0, 0.0, 0.0))
instPinTail.rotateAboutAxis(axisPoint=(0.0, 0.0, 0.0),
                            axisDirection=(0.0, 0.0, 1.0), angle=90.0)
instPinTail.translate(vector=(0.0, 0.0, -0.4))

# Creating the track part
#
sketch6 = myModel.Sketch(name='__profile__', sheetSize=200.0)
geomsketch6, vertsketch6, dimsketch6 = sketch6.geometry, sketch6.vertices, sketch6.dimensions
sketch6.sketchOptions.setValues(sheetSize=200.0, gridSpacing=5.0, grid=ON,
                                gridFrequency=2, constructionGeometry=ON,
                                dimensionTextHeight=5.0, decimalPlaces=2)
sketch6.setPrimaryObject(option=STANDALONE)
vp.view.setValues(width=264.73, height=169.23)
vp.view.setValues(width=442.04, height=282.58)
sketch6.unsetPrimaryObject()
del myModel.sketches['__profile__']

sketch7 = myModel.Sketch(name='__profile__', sheetSize=10.0)
geomsketch7, vertsketch7, dimsketch7 = sketch7.geometry, sketch7.vertices, sketch7.dimensions
sketch7.sketchOptions.setValues(sheetSize=10.0, gridSpacing=0.2, grid=ON,
    gridFrequency=2, constructionGeometry=ON, dimensionTextHeight=0.2,
    decimalPlaces=2)
sketch7.setPrimaryObject(option=STANDALONE)
vp.view.setValues(width=14.402, height=9.207)
vp.view.setValues(width=16.545, height=10.577)
sketch7.Spot(point=(0.0, -3.0))
sketch7.Spot(point=(0.4, -3.0))
sketch7.Spot(point=(0.4, -3.8))
sketch7.Spot(point=(-0.4, -3.8))
sketch7.Spot(point=(-0.4, -3.0))
myModel.sketches['__profile__'].sketchOptions.setValues(
    sheetSize=10.0, gridSpacing=0.025, grid=ON, gridFrequency=2,
    constructionGeometry=ON, dimensionTextHeight=0.2, decimalPlaces=2,
    gridSnap=ON, preselection=ON)
vp.view.setValues(width=3.136, height=2.0048,
    cameraPosition=(-0.14978, -3.5257, 9.4281), cameraTarget=(-0.14978,
    -3.5257, 0))
vp.view.fitView()
vp.view.setValues(width=2.1941, height=1.4026)
sketch7.Spot(point=(0.3, -2.95))
sketch7.Spot(point=(0.45, -2.95))
sketch7.Line(point1=(0.3, -2.95), point2=(0.45, -2.95))
sketch7.Line(point1=(0.45, -2.95), point2=(0.45, -3.85))
sketch7.Line(point1=(0.45, -3.85), point2=(-0.45, -3.85))
sketch7.Line(point1=(-0.45, -3.85), point2=(-0.45, -2.95))
sketch7.Line(point1=(-0.45, -2.95), point2=(-0.3, -2.95))
sketch7.Line(point1=(-0.3, -2.95), point2=(-0.3, -2.9))
sketch7.Line(point1=(-0.3, -2.9), point2=(-0.5, -2.9))
sketch7.Line(point1=(-0.5, -2.9), point2=(-0.5, -3.9))
sketch7.Line(point1=(-0.5, -3.9), point2=(0.5, -3.9))
sketch7.Line(point1=(0.5, -3.9), point2=(0.5, -2.9))
sketch7.Line(point1=(0.5, -2.9), point2=(0.3, -2.9))
sketch7.Line(point1=(0.3, -2.9), point2=(0.3, -2.95))
slot = myModel.Part(name='slot', dimensionality=THREE_D, type=DEFORMABLE_BODY)
partSlot = myModel.parts['slot']
slot.BaseSolidExtrude(sketch=sketch7, depth=3.0)
sketch7.unsetPrimaryObject()
partSlot = myModel.parts['slot']
vp.setValues(displayedObject=partSlot)
del myModel.sketches['__profile__']

slotCells = partSlot.cells
cells = slotCells.findAt(((0.433333, -2.9, 2.0), ), )

region = regionToolset.Region(cells=cells)
partSlot.SectionAssignment(region=region, sectionName='Section-1')

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Position all the instances
#
myAssembly.Instance(name='slot-1', part=partSlot, dependent=OFF)
instSlot = myAssembly.instances['slot-1']
instSlot.rotateAboutAxis(axisPoint=(0.0, 0.0, 0.0),
                         axisDirection=(0.0, 0.0, 1.0), angle=90.0)
instSlot.translate(vector=(0.0, 0.0, -1.5))
instCyl.rotateAboutAxis(axisPoint=(0.0, 0.0, 1.0),
                        axisDirection=(0.0, 0.0, 1.0), angle=180.0)
instPinHead.rotateAboutAxis(axisPoint=(0.0, 0.0, 1.0),
                            axisDirection=(0.0, 0.0, 1.0), angle=180.0)
instSlot.rotateAboutAxis(axisPoint=(0.0, 0.0, 1.0),
                         axisDirection=(0.0, 0.0, 1.0), angle=180.0)
instPinTail = myAssembly.instances['pinTail-1']
instPinTail.rotateAboutAxis(axisPoint=(0.0, 0.0, 1.0),
                            axisDirection=(0.0, 0.0, 1.0), angle=180.0)
instCyl.translate(vector=(3.0, 0.0, 0.0))
instPinHead.translate(vector=(3.0, 0.0, 0.0))
instPinTail.translate(vector=(3.0, 0.0, 0.0))
instSlot.translate(vector=(3.0, 0.0, 0.0))
instCyl.translate(vector=(0.5, 0.0, 0.0))
instPinHead.translate(vector=(0.5, 0.0, 0.0))
instSlot.translate(vector=(0.5, 0.0, 0.0))
instPinTail.translate(vector=(0.5, 0.0, 0.0))

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Creating display body
#
vp.assemblyDisplay.setValues(interactions=ON, constraints=ON, connectors=ON)
cylBottom =  myAssembly.instances['CylBottom-1']
refpt = cylBottom.referencePoints
myModel.DisplayBody(name='Constraint-1', instance=myAssembly.instances['cylinder-1'],
                    controlPoints=(refpt[1], ))
phrInst = myAssembly.instances['pinHeadRIGID-1']
refpt = phrInst.referencePoints
myModel.DisplayBody(name='Constraint-2', instance=instPinHead,
                    controlPoints=(refpt[1], ))
refpt = myAssembly.instances['pinHeadRIGID-1'].referencePoints
myModel.DisplayBody(name='Constraint-3', instance=instPinTail,
                    controlPoints=(refpt[1], ))
refpt = myAssembly.instances['track-1'].referencePoints
myModel.DisplayBody(name='Constraint-4',
    instance=myAssembly.instances['slot-1'], controlPoints=(refpt[1], ))
myAssembly.regenerate()
vp.setValues(displayedObject=myAssembly)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Create HistoryOutputRequests
#
refpts = myAssembly.instances['CylBottom-1'].referencePoints
refPoints1 = (refpts[1], )
regionDef = myAssembly.Set(referencePoints=refPoints1, name='cylinder')
vp.assemblyDisplay.setValues(step='Step-1')

myModel.historyOutputRequests['H-Output-1'].setValues(
    variables=('RF1', 'RF2', 'RF3', 'RM1', 'RM2', 'RM3'),
    frequency=200, region=regionDef)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Create Job
#
myJob = mdb.Job(name='cylcammech', model='Model-1', type=ANALYSIS,
    explicitPrecision=SINGLE, nodalOutputPrecision=SINGLE, description='',
    userSubroutine='', numCpus=1, scratch='', echoPrint=OFF, modelPrint=OFF,
    contactPrint=OFF, historyPrint=OFF)

myJob.writeInput()
mdb.saveAs('cylcammech')