def roundSelection(dict={}):
model_1 = apex.currentModel()
try:
roundRadius = float(dict["roundRadius"])
except:
apex.enableShowOutput()
print("Invalid radius value!")
_target = apex.EntityCollection()
for selFace in apex.selection.getCurrentSelection():
for Edge in selFace.getEdges():
_target.append(Edge)
try:
result = apex.geometry.pushPull(
target=_target,
method=apex.geometry.PushPullMethod.Fillet,
behavior=apex.geometry.PushPullBehavior.FollowShape,
removeInnerLoops=False,
createBooleanUnion=False,
distance=roundRadius,
direction=[7.071067811865475e-01, 7.071067811865475e-01, 0.0])
except:
apex.enableShowOutput()
print("Rounding failed for \n", selFace.getBody().getPathName())
def StiffnessOptimizer(dict={}):
#apex.disableShowOutput()
model_1 = apex.currentModel()
try:
maxNumPts = int(dict["MaxNumOfPoints"])
except:
apex.enableShowOutput()
print(
"Need a number for the maximum number of points. Please have the correct input."
)
raise
dummyMaterial = apex.catalog.createMaterial(name="Steel",
description="",
color=[64, 254, 250])
dummyMaterial.update(elasticModulus=210.e+9,
poissonRatio=0.3,
density=7.8e-6)
newAssyName = datetime.datetime.now().strftime("Test_%Y.%m.%d_%Hh%Mm%Ss")
currAssy = model_1.createAssembly(name=newAssyName)
for selPart in apex.selection.getCurrentSelection():
_target = apex.EntityCollection()
_target.append(selPart)
apex.attribute.assignMaterial(material=dummyMaterial, target=_target)
selPart.setParent(currAssy)
context_ = currAssy
study = apex.getPrimaryStudy()
study.createScenarioByModelRep(
context=context_,
simulationType=apex.studies.SimulationType.NormalModes)
study = apex.getPrimaryStudy()
currScenario = study.getScenario(name="Mode Scenario " +
currAssy.getName())
"""
simSetting1 = currScenario.simulationSettings
simSetting1.partReduction = False
simSetting1.freqRangeLower = 1000.
simSetting1.freqRangeUpper = float('NaN')
simSetting1.stopCalculation = True
simSetting1.maxModes = 10
currScenario.simulationSettings = simSetting1
"""
model_1.save()
currScenario.execute()
executedscenario_1 = scenario1.getLastExecutedScenario()
def ExpandSplit(dict={}):
try:
distance = float(dict["distance"])
except ValueError:
apex.enableShowOutput()
print("Non-numeric input for distance, must be a number!")
raise
model_1 = apex.currentModel()
SelectedAssyName = ""
_splitter = apex.EntityCollection()
for Assembly in apex.selection.getCurrentSelection():
SelectedAssyName = Assembly.getName()
for Part in Assembly.getParts(True):
for Solid in Part.getSolids():
for Face in Solid.getFaces():
_splitter.append(Face)
if dict["splitSolids"] == 'True':
includeSolid = True
else:
includeSolid = False
if dict["splitSurfaces"] == 'True':
includeSurface = True
else:
includeSurface = False
_target = apex.EntityCollection()
for Part in model_1.getParts(True):
if SelectedAssyName not in Part.getPathName():
if Part.getVisibility():
if includeSolid:
for Solid in Part.getSolids():
if Solid.getVisibility():
_target.append(Solid)
if includeSurface:
for Surface in Part.getSurfaces():
if Surface.getVisibility():
_target.append(Surface)
try:
result = apex.geometry.splitEntityWithOffsetFaces(
target=_target,
splitter=_splitter,
offset=(
-1.0 * distance
), # Negative value to make it expand outwards, it does inwards otherwise
splitBehavior=apex.geometry.GeometrySplitBehavior.Partition)
except:
print(
"Split failed, ty using the Apex builtin tool instead. It is under partitioning, using offset."
)
apex.enableShowOutput()
if dict["suppressVertices"] == 'True':
_target = apex.EntityCollection()
for Part in model_1.getParts(True):
if SelectedAssyName not in Part.getPathName():
for Surface in Part.getSurfaces():
if Surface.getVisibility():
_target.append(Surface.getVertices())
try:
result = apex.geometry.suppressOnly(
target=_target,
maxEdgeAngle=1.000000000000000e+01,
maxFaceAngle=5.000000000000000,
keepVerticesAtCurvatureChange=False,
cleanupTol=1.000000000000000,
forceSuppress=False)
except:
apex.enableShowOutput()
raise
def ArcWeldAutomesh(dict={}):
import apex
from apex.construct import Point3D, Point2D
from math import sqrt, pow, degrees, acos, pi
import os
from Midsurface import Midsurface as GetMidsurface
from SuppressFeatures import SuppressFeatures
from CreateBeads import BeadBySweep
from SplitByTrajectories import SplitByTrajectories
from MeshPartitions import CreateMeshPartitions
from MeshNONPartitions import CreateMeshNONPartitions
gotDict = dict
try:
apex.session.displayStatusMessage("Getting midsurface...")
GetMidsurface()
try:
apex.session.displayStatusMessage("Suppressing features...")
SuppressFeatures()
try:
apex.session.displayStatusMessage(
"Creating refinement regions...")
BeadBySweep(gotDict)
try:
apex.session.displayStatusMessage("Split regions...")
SplitByTrajectories()
try:
apex.session.displayStatusMessage("Fine meshing...")
CreateMeshPartitions(gotDict)
try:
apex.session.displayStatusMessage(
"Coarse meshing...")
CreateMeshNONPartitions(gotDict)
except:
apex.enableShowOutput()
print("Coarse meshing failed!")
except:
apex.enableShowOutput()
print("Fine meshing failed!")
except:
apex.enableShowOutput()
print("Split failed!")
except:
apex.enableShowOutput()
print("Create refinement regions failed!")
except:
apex.enableShowOutput()
print("Suppress features failed!")
except:
apex.enableShowOutput()
print("Midsurface failed!")
def buildLapShear(dict={}):
# - Get the data from the dictionary
try:
Thick01 = float(dict["Thick01"])
Thick02 = float(dict["Thick02"])
GapSize = float(dict["GapSize"])
spotSize = float(dict["SpotSize"])
except:
apex.enableShowOutput()
print("Please use only numbers as input in the fields.")
## Define max and min thickness
if Thick01 >= Thick02:
maxThick = Thick01
minThick = Thick02
else:
maxThick = Thick02
minThick = Thick01
avgThick = (maxThick + minThick) / 2.0
if maxThick < 1.30:
CouponLength = 105
CouponWidth = 45
CouponOverlap = 35
SampleLength = 175
GrippedLength = 40
UnclampedLength = 95
else:
CouponLength = 138
CouponWidth = 60
CouponOverlap = 45
SampleLength = 230
GrippedLength = 62.5
UnclampedLength = 105
model_1 = apex.currentModel()
ParentAssy = model_1.createAssembly(name="AWS-RSW-LapShear")
# -- Build Upper sheet
Sheet01 = apex.createPart()
result = apex.geometry.createBoxByLocationOrientation(
name='Sheet01',
description='',
length=CouponLength, # Length
height=CouponWidth, # Width
depth=Thick02, # Thickness
origin=apex.Coordinate(0.0, 0.0, Thick01),
orientation=apex.construct.createOrientation(alpha=0.0, beta=0.0, gamma=0.0)
)
res = Sheet01.setParent(ParentAssy)
res = Sheet01.update(name=f'UpperSheet-{Thick02}mm')
# -- Build lower sheet
Sheet02 = apex.createPart()
result = apex.geometry.createBoxByLocationOrientation(
name='Sheet02',
description='',
length=CouponLength, # Length
height=CouponWidth, # Width
depth=Thick01, # Thickness
origin=apex.Coordinate(0.0, 0.0, 0.0),
orientation=apex.construct.createOrientation(alpha=0.0, beta=0.0, gamma=0.0)
)
res = Sheet02.setParent(ParentAssy)
res = Sheet02.update(name=f'LowerSheet-{Thick01}mm')
# -- Translate sheet to the correct overlap length
_translateSheet = apex.EntityCollection()
_translateSheet.append(Sheet02.getSolids()[0])
newEntities = apex.transformTranslate(
target=_translateSheet,
direction=[-1.0, 0.0, 0.0],
distance=(CouponLength - CouponOverlap),
makeCopy=False
)
# -- Creating split regions
cylPart = model_1.createPart(name="Cylinder")
result = apex.geometry.createCylinderByLocationOrientation(
name='',
description='',
length=(maxThick + minThick),
radius=spotSize,
sweepangle=360.0,
origin=apex.Coordinate(CouponOverlap / 2.0, CouponWidth / 2.0, 0.0),
orientation=apex.construct.createOrientation(alpha=0.0, beta=0.0, gamma=0.0)
)
entities_1 = apex.EntityCollection()
entities_1.append(result)
entities_1.hide()
result = apex.geometry.createCylinderByLocationOrientation(
name='',
description='',
length=(maxThick + minThick),
radius=1.5 * spotSize,
sweepangle=360.0,
origin=apex.Coordinate(CouponOverlap / 2.0, CouponWidth / 2.0, 0.0),
orientation=apex.construct.createOrientation(alpha=0.0, beta=0.0, gamma=0.0)
)
entities_1 = apex.EntityCollection()
entities_1.append(result)
entities_1.hide()
result = apex.geometry.createCylinderByLocationOrientation(
name='',
description='',
length=(maxThick + minThick),
radius=2.0 * spotSize,
sweepangle=360.0,
origin=apex.Coordinate(CouponOverlap / 2.0, CouponWidth / 2.0, 0.0),
orientation=apex.construct.createOrientation(alpha=0.0, beta=0.0, gamma=0.0)
)
# -- Split sheets
_target = apex.EntityCollection()
_target.append( Sheet01.getSolids()[0] )
_target.append( Sheet02.getSolids()[0] )
_splitter = apex.EntityCollection()
for Solid in cylPart.getSolids():
_splitter.extend(Solid.getFaces())
result = apex.geometry.split(
target = _target,
splitter = _splitter,
splitBehavior = apex.geometry.GeometrySplitBehavior.Partition
)
entities_1 = apex.EntityCollection()
entities_1.append(cylPart)
#apex.deleteEntities(entities_1)
_plane = apex.construct.Plane(
apex.construct.Point3D(CouponOverlap / 2.0, CouponWidth / 2.0, 0.0),
apex.construct.Vector3D(1.0, 0.0, 0.0)
)
result = apex.geometry.splitWithPlane(
target=_target,
plane=_plane,
splitBehavior=apex.geometry.GeometrySplitBehavior.Partition
)
# -- Translate
_translateSheet = apex.EntityCollection()
_translateSheet.append(Sheet01.getSolids()[0])
newPosition = apex.transformTranslate(
target=_translateSheet,
direction=[0.0, 0.0, 1.0],
distance=GapSize,
makeCopy=False
)
# -- Create grippers
if dict["CreateGrippers"] == 'True':
# -- Build Upper gripper
UpperGripper = apex.createPart()
result = apex.geometry.createBoxByLocationOrientation(
name='UpperGripper',
description='',
length=1.2 * GrippedLength, # Length
height=CouponWidth, # Width
depth=3 * Thick02, # Thickness
origin=apex.Coordinate(0.0, 0.0, Thick01),
orientation=apex.construct.createOrientation(alpha=0.0, beta=0.0, gamma=0.0)
)
res = UpperGripper.setParent(ParentAssy)
res = UpperGripper.update(name=f'UpperGripper')
# -- Translate
_translateSheet = apex.EntityCollection()
_translateSheet.append(UpperGripper.getSolids()[0])
newPosition = apex.transformTranslate(
target=_translateSheet,
direction=[1.0, 0.0, 0.0],
distance=(CouponLength - GrippedLength),
makeCopy=False
)
newPosition = apex.transformTranslate(
target=_translateSheet,
direction=[0.0, 0.0, -1.0],
distance=(Thick02 + GapSize),
makeCopy=False
)
_target = apex.EntityCollection()
_target.append(UpperGripper.getSolids()[0])
_subtractingEntities = apex.EntityCollection()
_subtractingEntities.append(Sheet01.getSolids()[0])
result = apex.geometry.subtractBoolean(
target=_target,
subtractingEntity=_subtractingEntities,
retainOriginalBodies=True
)
# -- Build Lower gripper
LowerGripper = apex.createPart()
result = apex.geometry.createBoxByLocationOrientation(
name='LowerGripper',
description='',
length=1.2 * GrippedLength, # Length
height=CouponWidth, # Width
depth=3 * Thick01, # Thickness
origin=apex.Coordinate(0.0, 0.0, Thick01),
orientation=apex.construct.createOrientation(alpha=0.0, beta=0.0, gamma=0.0)
)
res = LowerGripper.setParent(ParentAssy)
res = LowerGripper.update(name=f'LowerGripper')
# -- Translate
_translateSheet = apex.EntityCollection()
_translateSheet.append(LowerGripper.getSolids()[0])
newPosition = apex.transformTranslate(
target=_translateSheet,
direction=[-1.0, 0.0, 0.0],
distance=(CouponLength - CouponOverlap + 0.2 * GrippedLength),
makeCopy=False
)
newPosition = apex.transformTranslate(
target=_translateSheet,
direction=[0.0, 0.0, -1.0],
distance=(Thick01 + Thick02),
makeCopy=False
)
_target = apex.EntityCollection()
_target.append(LowerGripper.getSolids()[0])
_subtractingEntities = apex.EntityCollection()
_subtractingEntities.append(Sheet02.getSolids()[0])
result = apex.geometry.subtractBoolean(
target=_target,
subtractingEntity=_subtractingEntities,
retainOriginalBodies=True
)
_target = apex.EntityCollection()
for Edge in UpperGripper.getSolids()[0].getEdges():
_target.append(Edge)
for Edge in LowerGripper.getSolids()[0].getEdges():
_target.append(Edge)
try:
result = apex.geometry.pushPull(
target=_target,
method=apex.geometry.PushPullMethod.Fillet,
behavior=apex.geometry.PushPullBehavior.FollowShape,
removeInnerLoops=False,
createBooleanUnion=False,
distance=0.05,
direction=[7.071067811865475e-01, 7.071067811865475e-01, 0.0]
)
except:
pass
# -- Perform meshing if requested
if dict["Meshing"] != 'No mesh':
if dict["Meshing"] == "For weld":
refLevel = 4.0 # Ref level for weld only
else:
refLevel = 8.0 # Ref level for pull test
# - Meshing Sheet 01 and Sheet 02
refPoint = apex.Coordinate(CouponOverlap / 2.0, CouponWidth / 2.0, 0.0)
listOfSolids = [Sheet01.getSolids()[0], Sheet02.getSolids()[0]]
for i in range(len(listOfSolids)):
proxSearch = apex.utility.ProximitySearch()
ans = proxSearch.insertList(list(listOfSolids[i].getCells()))
resSearch = proxSearch.findNearestObjects(location=refPoint, numObjects=4)
cellsToMesh = apex.EntityCollection()
for elem in resSearch.foundObjects():
cellsToMesh.append(elem)
_SweepFace = apex.EntityCollection()
result = apex.mesh.createHexMesh(
name="",
target=cellsToMesh,
meshSize=(minThick / refLevel),
surfaceMeshMethod=apex.mesh.SurfaceMeshMethod.Pave,
mappedMeshDominanceLevel=2,
elementOrder=apex.mesh.ElementOrder.Linear,
refineMeshUsingCurvature=False,
elementGeometryDeviationRatio=0.10,
elementMinEdgeLengthRatio=0.20,
createFeatureMeshOnWashers=False,
createFeatureMeshOnArbitraryHoles=False,
preserveWasherThroughMesh=True,
sweepFace=_SweepFace,
hexMeshMethod=apex.mesh.HexMeshMethod.Auto
)
resSearch = proxSearch.findNearestObjects(location=refPoint, numObjects=8)
cellsToMesh = apex.EntityCollection()
for elem in resSearch.foundObjects():
if len(elem.getElements()) > 0: # Check if it has a mesh already
pass
else:
cellsToMesh.append(elem)
seedEdge = apex.EntityCollection()
for Edge in elem.getEdges():
if i == 0:
if 0.9 * Thick02 <= Edge.getLength() <= 1.1 * Thick02:
seedEdge.append(Edge)
else:
if 0.9 * Thick01 <= Edge.getLength() <= 1.1 * Thick01:
seedEdge.append(Edge)
result = apex.mesh.createEdgeSeedUniformByNumber(
target=seedEdge,
numberElementEdges=2
)
for Cell in cellsToMesh:
vecFaces = Cell.getFaces()
for Face in vecFaces:
paramU = Face.evaluatePointOnFace(Face.getCentroid()).u
paramV = Face.evaluatePointOnFace(Face.getCentroid()).v
normalAtPoint = Face.evaluateNormal(paramU, paramV)
if abs(normalAtPoint.z) == 1: # -Extrusion direction for meshing
_SweepFace = apex.EntityCollection()
_SweepFace.append(Face)
meshCell = apex.EntityCollection()
meshCell.append(Cell)
result = apex.mesh.createHexMesh(
name="",
target=meshCell,
meshSize=maxThick/1.5,
surfaceMeshMethod=apex.mesh.SurfaceMeshMethod.Pave,
mappedMeshDominanceLevel=2,
elementOrder=apex.mesh.ElementOrder.Linear,
refineMeshUsingCurvature=False,
elementGeometryDeviationRatio=0.10,
elementMinEdgeLengthRatio=0.20,
createFeatureMeshOnWashers=False,
createFeatureMeshOnArbitraryHoles=False,
preserveWasherThroughMesh=True,
sweepFace=_SweepFace,
hexMeshMethod=apex.mesh.HexMeshMethod.Auto
)
break
_target = apex.EntityCollection()
_target.append(LowerGripper.getSolids()[0])
_target.append(UpperGripper.getSolids()[0])
featuremeshtypes_2 = apex.mesh.FeatureMeshTypeVector()
result = apex.mesh.createSurfaceMesh(
name="",
target=_target,
meshSize=minThick,
meshType=apex.mesh.SurfaceMeshElementShape.Quadrilateral,
meshMethod=apex.mesh.SurfaceMeshMethod.Auto,
mappedMeshDominanceLevel=2,
elementOrder=apex.mesh.ElementOrder.Linear,
refineMeshUsingCurvature=False,
elementGeometryDeviationRatio=0.10,
elementMinEdgeLengthRatio=0.20,
growFaceMeshSize=False,
faceMeshGrowthRatio=1.2,
createFeatureMeshes=False,
featureMeshTypes=featuremeshtypes_2,
projectMidsideNodesToGeometry=True,
useMeshFlowOptimization=True,
meshFlow=apex.mesh.MeshFlow.Grid
)
import apex
apex.enableShowOutput()
def CountVisibleElements(dict={}):
apex.setScriptUnitSystem(unitSystemName=r'''mm-kg-s-N''')
model_1 = apex.currentModel()
numOfElements = 0
listOfParts = model_1.getParts(True)
for Part in listOfParts:
if Part.getVisibility():
for Mesh in Part.getMeshes():
numOfElements += len(Mesh.getElements())
print('Elements in all visible meshes: ', numOfElements)
def createRefRegion(dict={}):
model_1 = apex.currentModel()
### Math functions needed when numpy is not available
def multip3D(v1, k): # Addition of two ponts in 3D
return [x * k for x in v1]
def add3D(v1, v2): # Addition of two ponts in 3D
return [x + y for x, y in zip(v1, v2)]
def subtract3D(v1, v2): # Subtraction of two ponts in 3D
return [x - y for x, y in zip(v1, v2)]
def distance3D(v1, v2): # Distance between two points in 3D
return sqrt(abs(sum((a - b) for a, b in zip(v1, v2))))
def dotproduct(v1, v2): # Dot product of two vectors (list), cosine of the angle
return sum((a * b) for a, b in zip(v1, v2))
def length(v): # Length of a vector (list)
return sqrt(dotproduct(v, v))
def angle(v1, v2): # Angle between two vectors in degrees (lists)
return degrees(acos(dotproduct(v1, v2) / (length(v1) * length(v2)))) # Return the angle in degrees
def cross(a, b): # Cross-product (orthogonal vector) of two vectors (list)
c = [a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0]]
return c # List of three components (x,y,z) of the orthogonal vector
def doCircle(diam=8.0):
part_1 = model_1.getCurrentPart()
if part_1 is None:
part_1 = model_1.createPart()
sketch_1 = part_1.createSketchOnGlobalPlane(
name='',
plane=apex.construct.GlobalPlane.YZ,
alignSketchViewWithViewport=True
)
circle_1 = sketch_1.createCircleCenterPoint(
name="",
centerPoint=Point2D(0, 0),
pointOnCircle=Point2D(0, diam / 2)
)
return sketch_1.completeSketch(fillSketches=True)
try:
refDiameter = float(dict["refDiam"])
except:
apex.enableShowOutput()
print("\nInvalid diameter value!")
raise
try:
TrajAssy = model_1.getAssembly(pathName="Refinement regions")
except:
TrajAssy = model_1.createAssembly(name="Refinement regions")
try:
if TrajAssy.getPart(name=f"RefDiam_{refDiameter}"):
pass
else:
SpecifiedDiameter = TrajAssy.createPart(name=f"RefDiam_{refDiameter}")
except:
apex.enableShowOutput()
print("Part creation with refinement diameter info failed!")
allLongEdges = apex.EntityCollection()
for selElement in apex.selection.getCurrentSelection():
# If selection is is a Part, go check what is inside
if selElement.getVisibility():
if selElement.entityType == apex.EntityType.Part:
for Solid in selElement.getSolids():
if Solid.getVisibility():
maxEdgeLength = 0.0
selectedEdge = apex.EntityType.Edge
for Edge in Solid.getEdges():
if Edge.getLength() > maxEdgeLength:
selectedEdge = Edge
maxEdgeLength = Edge.getLength()
allLongEdges.append(selectedEdge)
for Surface in selElement.getSurfaces():
if Surface.getVisibility():
maxEdgeLength = 0.0
selectedEdge = apex.EntityType.Edge
for Edge in Surface.getEdges():
if Edge.getLength() > maxEdgeLength:
selectedEdge = Edge
maxEdgeLength = Edge.getLength()
allLongEdges.append(selectedEdge)
# If selection is an Assembly, get the Parts and check what is inside
if selElement.entityType == apex.EntityType.Assembly:
if selElement.getVisibility():
for Part in selElement.getParts(True):
if Part.getVisibility():
for Solid in Part.getSolids():
if Solid.getVisibility():
maxEdgeLength = 0.0
selectedEdge = apex.EntityType.Edge
for Edge in Solid.getEdges():
if Edge.getLength() > maxEdgeLength:
selectedEdge = Edge
maxEdgeLength = Edge.getLength()
allLongEdges.append(selectedEdge)
for Surface in Part.getSurfaces():
if Surface.getVisibility():
maxEdgeLength = 0.0
selectedEdge = apex.EntityType.Edge
for Edge in Surface.getEdges():
if Edge.getLength() > maxEdgeLength:
selectedEdge = Edge
maxEdgeLength = Edge.getLength()
allLongEdges.append(selectedEdge)
for selEdge in allLongEdges:
CurrPart = TrajAssy.createPart(name="Edge_{0}_{1}mm".format(selEdge.getId(), refDiameter))
maxPointSpacing = 2 #mm
if maxPointSpacing > 0:
trajStep = int(selEdge.getLength() / maxPointSpacing)
trajResolution = trajStep + 1 if trajStep > 2 else 3
else:
trajResolution = 4
paramRange = selEdge.getParametricRange()
delta = abs(paramRange['uEnd'] - paramRange['uStart']) / trajResolution
sampling = [(x * delta) + paramRange['uStart'] for x in range(0, trajResolution + 1)]
_PointCollection = apex.IPhysicalCollection()
PathPoints = []
for i in range(len(sampling)):
pointCoord = apex.Coordinate(selEdge.evaluateEdgeParametricCoordinate(sampling[i]).x ,
selEdge.evaluateEdgeParametricCoordinate(sampling[i]).y ,
selEdge.evaluateEdgeParametricCoordinate(sampling[i]).z)
_PointCollection.append(pointCoord)
PathPoints.append([selEdge.evaluateEdgeParametricCoordinate(sampling[i]).x ,
selEdge.evaluateEdgeParametricCoordinate(sampling[i]).y ,
selEdge.evaluateEdgeParametricCoordinate(sampling[i]).z])
newSpline = apex.geometry.createCurve(
target=_PointCollection,
behavior=apex.geometry.CurveBehavior.Spline
)
CircleDone = doCircle(diam=refDiameter)
## Move circle to a new point location
_target = apex.EntityCollection()
_target.append(CurrPart.getSurfaces()[0])
PathLength = sqrt(pow(PathPoints[0][0], 2) + pow(PathPoints[0][1], 2) + pow(PathPoints[0][2], 2))
apex.transformTranslate(target=_target,
direction=[PathPoints[0][0], PathPoints[0][1], PathPoints[0][2]],
distance=PathLength,
makeCopy=False)
## Rotate the circle
TurnAngle = angle([1, 0, 0], [a - b for a, b in zip(PathPoints[1], PathPoints[0])])
if TurnAngle == 180:
TurnAngle = 0
apex.transformRotate(target=_target,
axisDirection=cross([1, 0, 0], [a - b for a, b in zip(PathPoints[1], PathPoints[0])]),
axisPoint=Point3D(PathPoints[0][0], PathPoints[0][1], PathPoints[0][2]),
angle=TurnAngle,
makeCopy=False)
## Do the sweep
_target = apex.EntityCollection()
_target.append(CurrPart.getSurfaces()[0])
_path = apex.EntityCollection()
_path.append(CurrPart.getCurves()[0])
_lockDirection = apex.construct.Vector3D(0.0, 0.0, 0.0)
try:
result = apex.geometry.createGeometrySweepPath(
target=_target,
path=_path,
scale=0.0,
twist=0.0,
profileSweepAlignmentMethod=apex.geometry.SweepProfileAlignmentMethod.Normal,
islocked=False,
lockDirection=_lockDirection,
profileClamp=apex.geometry.SweepProfileClampingMethod.Smooth
)
CurrPart.getSolids()[0].update(enableTransparency=True, transparencyLevel=50)
DelEntities = apex.EntityCollection()
for Surface in CurrPart.getSurfaces():
DelEntities.append(Surface)
apex.deleteEntities(DelEntities)
if dict["extendRegion"] == "True":
for Face in CurrPart.getSolids()[0].getFaces():
XSectionArea = 3.14159 * (refDiameter / 2) ** 2
if (0.9 * XSectionArea) < Face.getArea() < (1.1 * XSectionArea):
_target = apex.EntityCollection()
_target.append(Face)
result = apex.geometry.pushPull(
target=_target,
method=apex.geometry.PushPullMethod.Normal,
behavior=apex.geometry.PushPullBehavior.FollowShape,
removeInnerLoops=False,
createBooleanUnion=False,
distance=refDiameter,
direction=[1.0, 1.0, 1.0]
)
except:
print("\nSweep failed!")
NewPartName = apex.getPart(selEdge.getBody().getPath()).getName() + "_(failed)"
ans = apex.getPart(selEdge.getBody().getPath()).update(name = NewPartName)
def createRefRegion(dict={}):
model_1 = apex.currentModel()
### Math functions needed when numpy is not available
def multip3D(v1, k): # Addition of two ponts in 3D
return [x * k for x in v1]
def add3D(v1, v2): # Addition of two ponts in 3D
return [x + y for x, y in zip(v1, v2)]
def subtract3D(v1, v2): # Subtraction of two ponts in 3D
return [x - y for x, y in zip(v1, v2)]
def distance3D(v1, v2): # Distance between two points in 3D
return sqrt(abs(sum((a - b) for a, b in zip(v1, v2))))
def dotproduct(v1, v2): # Dot product of two vectors (list), cosine of the angle
return sum((a * b) for a, b in zip(v1, v2))
def length(v): # Length of a vector (list)
return sqrt(dotproduct(v, v))
def angle(v1, v2): # Angle between two vectors in degrees (lists)
return degrees(acos(dotproduct(v1, v2) / (length(v1) * length(v2)))) # Return the angle in degrees
def cross(a, b): # Cross-product (orthogonal vector) of two vectors (list)
c = [a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0]]
return c # List of three components (x,y,z) of the orthogonal vector
def doCircle(diam=8.0):
part_1 = model_1.getCurrentPart()
if part_1 is None:
part_1 = model_1.createPart()
sketch_1 = part_1.createSketchOnGlobalPlane(
name='',
plane=apex.construct.GlobalPlane.YZ,
alignSketchViewWithViewport=True
)
circle_1 = sketch_1.createCircleCenterPoint(
name="",
centerPoint=Point2D(0, 0),
pointOnCircle=Point2D(0, diam / 2)
)
return sketch_1.completeSketch(fillSketches=True)
try:
refDiameter = float(dict["refDiam"])
except:
apex.enableShowOutput()
print("\nInvalid diameter value!")
raise
try:
TrajAssy = model_1.getAssembly(pathName="Refinement regions")
except:
TrajAssy = model_1.createAssembly(name="Refinement regions")
try:
if TrajAssy.getPart(name=f"RefDiam_{refDiameter}"):
pass
else:
SpecifiedDiameter = TrajAssy.createPart(name=f"RefDiam_{refDiameter}")
except:
print("Part creation failed!")
CurrPart = apex.createPart(name=f"FromEdge_{refDiameter}mm")
CurrPart.setParent(TrajAssy)
# - Merge contiguous edges into curves
_edgeCollection = apex.geometry.EdgeCollection()
_curveCollection = apex.geometry.CurveCollection()
for selElem in apex.selection.getCurrentSelection():
if selElem.entityType == apex.EntityType.Edge:
_edgeCollection.append(selElem)
elif selElem.entityType == apex.EntityType.Curve:
_curveCollection.append(selElem)
result_ = apex.geometry.createCurvesFromEdges(edges=_edgeCollection)
result_.extend(_curveCollection)
for k in range(len(result_)):
thisCurve = result_[k]
CurrPart = apex.createPart(name=f"FromEdge_L={int(thisCurve.getLength())}mm_D={refDiameter}mm")
CurrPart.setParent(TrajAssy)
thisCurve.setParent(CurrPart)
CircleDone = doCircle(diam=refDiameter)
StartPoint = thisCurve.getExteriorVertices()[0]
## Move circle to a new point location
_target = apex.EntityCollection()
_target.append(CurrPart.getSurfaces()[0])
PathLength = sqrt(pow(StartPoint.getX(), 2) + pow(StartPoint.getY(), 2) + pow(StartPoint.getZ(), 2))
apex.transformTranslate(target=_target,
direction=[StartPoint.getX(), StartPoint.getY(), StartPoint.getZ()],
distance=PathLength,
makeCopy=False)
## Rotate the circle
tangVec = thisCurve.evaluateTangent(StartPoint)
TurnAngle = angle([1, 0, 0], [tangVec.getX(), tangVec.getY(), tangVec.getZ()])
axisDir = cross([1, 0, 0], [tangVec.getX(), tangVec.getY(), tangVec.getZ()])
if TurnAngle == 180:
TurnAngle = 0
apex.transformRotate(target=_target,
axisDirection=axisDir,
axisPoint=StartPoint,
angle=TurnAngle,
makeCopy=False)
## Do the sweep
_target = apex.EntityCollection()
_target.append(CurrPart.getSurfaces()[0])
_path = apex.EntityCollection()
_path.append(CurrPart.getCurves()[0])
_lockDirection = apex.construct.Vector3D(0.0, 0.0, 0.0)
try:
result = apex.geometry.createGeometrySweepPath(
target=_target,
path=_path,
scale=0.0,
twist=0.0,
profileSweepAlignmentMethod=apex.geometry.SweepProfileAlignmentMethod.Normal,
islocked=False,
lockDirection=_lockDirection,
profileClamp=apex.geometry.SweepProfileClampingMethod.Smooth
)
DelEntities = apex.EntityCollection()
for Surface in CurrPart.getSurfaces():
DelEntities.append(Surface)
apex.deleteEntities(DelEntities)
if dict["extendRegion"] == "True":
for pointLocation in thisCurve.getExteriorVertices():
result = apex.geometry.createSphereByLocationOrientation(
name='Sphere',
description='',
radius=refDiameter/2.0,
origin=pointLocation,
orientation=apex.construct.createOrientation(alpha=0.0, beta=0.0, gamma=0.0)
)
_target = apex.EntityCollection()
_target.extend(CurrPart.getSolids())
result = apex.geometry.mergeBoolean(
target=_target,
retainOriginalBodies=False,
mergeSolidsAsCells=False
)
CurrPart.getSolids()[0].update(enableTransparency=True, transparencyLevel=50)
except:
print("\nSweep failed!")
raise
def Midsurface(dict={}):
#===================================================================
## Initializing Apex code
apex.setScriptUnitSystem(unitSystemName=r'''mm-kg-s-N''')
model_1 = apex.currentModel()
# ===================================================================
## Extract midsurface for all parts
numOfInvisible = 0
numOfFailed = 0
numOfMultiple = 0
numOfCreated = 0
numOfParts = len(model_1.getParts(recursive=True))
model_1 = apex.currentModel()
for Assembly in apex.selection.getCurrentSelection():
for Part in Assembly.getParts(True):
_target = apex.entityCollection()
if Part.getVisibility():
try:
listOfSolids = Part.getSolids(
) # Get a list of all solids for a given part
for Solid in listOfSolids: # Append this list of solids to the _target variable
_target = apex.entityCollection()
if Solid.getVisibility():
_target.append(Solid)
A_old = apex.catalog.getSectionDictionary()
result = apex.geometry.assignConstantThicknessMidSurface(
target=_target,
autoAssignThickness=True,
autoAssignTolerance=5.0e-02)
A_new = apex.catalog.getSectionDictionary()
new_thickness = {
k: A_new[k]
for k in set(A_new) - set(A_old)
}
for key, value in new_thickness.items():
nthickness = value.thickness
if len(Part.getSurfaces()) > 1:
Part.update(
name="{0}_(multiple)".format(Part.getName()))
numOfMultiple += 1
else:
for entity in result: #'result' comes from the resulting collection of the midsurface extraction
if entity.entityType is apex.EntityType.Surface:
CurrPartPath = apex.getPart(
entity.getPath())
CurrPartPath.update(
name="{0}_{1}mm".format(
CurrPartPath.getName(),
str(round(float(nthickness),
2)).replace(".", ",")))
numOfCreated += 1
Solid.hide()
except:
Part.update(name="{0}_(failed)".format(Part.getName()))
numOfFailed += 1
apex.enableShowOutput()
else:
numOfInvisible += 1
print(
"Found {4} parts with solids in total.\nThere were {0} parts not visible, only visible parts are processed: created {1} midsurfaces.\nParts with multple thickness: {2} \nFailed parts: {3}"
.format(numOfInvisible, numOfCreated, numOfMultiple, numOfFailed,
numOfParts))