def OrganizeSolids(dict={}):
#===================================================================
## Initializing Apex code
apex.setScriptUnitSystem(unitSystemName=r'''mm-kg-s-N''')
try:
numOfSolidsChanged = 0
for Part in apex.currentModel().getParts(recursive=True):
if len(Part.getSolids()) > 1:
for Solid in Part.getSolids()[1:]:
if Solid.getVisibility():
if dict["useSolidName"] == 'True':
newPart = apex.createPart(name=Solid.getName())
Solid.setParent(newPart)
numOfSolidsChanged += 1
if Part.getParent():
newPart.setParent(Part.getParent())
else:
newPart = apex.createPart(name=Part.getName())
Solid.setParent(newPart)
numOfSolidsChanged += 1
if Part.getParent():
newPart.setParent(Part.getParent())
print("Reorganized {0} solids.".format(numOfSolidsChanged))
except:
print("Operation failed or not performed.")
def CreateMeshPartitions(dict={}):
# ===================================================================
## Initializing Apex code
apex.setScriptUnitSystem(unitSystemName=r'''mm-kg-s-N''')
model_1 = apex.currentModel()
## Collect faces to mesh
_targetFine = apex.entityCollection()
listOfLengths = []
listOfDiameters = []
MeshSize = float(dict["MeshSize"])
try:
listOfTrajectories = model_1.getAssembly("Trajectories").getParts(True)
listOfAllParts = []
for Part in model_1.getParts(True):
if "Trajectories" not in Part.getPath():
listOfAllParts.append(Part)
for Part in listOfTrajectories:
if 'RefDiam' in Part.getName():
_, Diam = Part.getName().split('_')
listOfDiameters.append(float(Diam))
else:
if len(Part.getCurves()) > 0:
listOfLengths.append(Part.getCurves()[0].getLength())
maxDiameter = max(
listOfDiameters) #Getting the max diameter to use as search range
## Getting all faces from all parts that are not under 'Trajectories'
facesToMesh = apex.EntityCollection()
for Part in listOfAllParts:
for Surface in Part.getSurfaces():
for Face in Surface.getFaces():
if Face.getArea() <= (1.1 * 3.14159 * maxDiameter *
maxDiameter):
facesToMesh.append(Face)
apex.mesh.createSurfaceMesh(
name="",
target=facesToMesh,
meshSize=MeshSize,
meshType=apex.mesh.SurfaceMeshElementShape.Mixed,
meshMethod=apex.mesh.SurfaceMeshMethod.Pave,
mappedMeshDominanceLevel=2,
elementOrder=apex.mesh.ElementOrder.Linear,
meshUsingPrincipalAxes=False,
refineMeshUsingCurvature=True,
elementGeometryDeviationRatio=0.10,
elementMinEdgeLengthRatio=0.50,
createFeatureMeshOnFillets=False,
createFeatureMeshOnChamfers=False,
createFeatureMeshOnWashers=False,
createFeatureMeshOnQuadFaces=False)
except:
print("Meshing failed or not performed.")
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))
for Part in model_1.getParts(recursive=True):
if 'Trajectories' not in Part.getPathName():
_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()
_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}_CHECK(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
except:
Part.update(
name="{0}_CHECK(failed)".format(Part.getName()))
numOfFailed += 1
else:
numOfInvisible += 1
def ExportBDF(dict={}):
# ===================================================================
## Initializing Apex code
apex.setScriptUnitSystem(unitSystemName=r'''mm-kg-s-N''')
# Export mesh to BDF
model_1 = apex.currentModel()
pathToSave = dict["DirPath"]
for Part in model_1.getParts(True):
if "=" not in Part.getName():
if Part.getVisibility():
try:
Part.exportFEModel(
filename=os.path.join(
pathToSave,
Part.getName().replace(",", ".") + ".bdf"),
unitSystem="m-kg-s-N-K",
exportWideFormat=False,
exportHierarchicalFiles=False,
resultOutputType=apex.attribute.
NastranResultOutputType.Hdf5,
renumberMethod=apex.attribute.ExportRenumberMethod.
Internal,
apexEngineeringAbstractions=False,
)
except:
pass
for f in os.listdir(pathToSave):
if '.bdf' in f:
BDFPath = os.path.join(pathToSave, f)
newContent = ""
print(f)
with open(BDFPath, 'r') as oldBDF:
for line in oldBDF:
line = line.strip()
spaceVec = " "
if 'CQUAD' in line:
line = ' '.join(line.split())
vecStr = line.split()
vecStr[2] = '1'
finString = ""
for elem in vecStr:
finString += elem + spaceVec[0:8 - len(elem)]
newContent += finString + '\n'
elif 'CTRIA' in line:
line = ' '.join(line.split())
vecStr = line.split()
vecStr[2] = '1'
finString = ""
for elem in vecStr:
finString += elem + spaceVec[0:8 - len(elem)]
newContent += finString + '\n'
#elif 'PSHELL' in line:
# pass
else:
newContent += line + '\n'
with open(BDFPath, 'w') as newBDF:
newBDF.write(newContent)
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 ShowNoMeshed(dict={}):
#===================================================================
## Initializing Apex code
apex.setScriptUnitSystem(unitSystemName=r'''mm-kg-s-N''')
model_1 = apex.currentModel()
# ===================================================================
for Part in model_1.getParts(recursive=True):
if 'Trajectories' not in Part.getPathName():
_target = apex.entityCollection()
if Part.getMeshes():
Part.hide()
else:
Part.show()
def SuppressEdges(dict={}):
#===================================================================
## Initializing Apex code
apex.setScriptUnitSystem(unitSystemName=r'''mm-kg-s-N''')
model_1 = apex.currentModel()
_target = apex.entityCollection()
listOfVertices = []
for part in model_1.getParts(True):
if part.getVisibility():
if 'Trajectories' not in part.getPath():
for Solid in part.getSolids():
if Solid.getVisibility():
for Vertex in Solid.getVertices():
listOfEdges = []
listOfLengths = []
for Edge in Vertex.getConnectedEdges():
listOfEdges.append(Edge.getId())
listOfLengths.append(Edge.getLength())
if len(
listOfEdges
) > 2: # Suppress edges with more than 2 connections at the vertex
sortedByNumber = [
int(x) for _, x in sorted(
zip(listOfLengths, listOfEdges))
]
_target.append(
Solid.getEdge(id=sortedByNumber[0]))
"""
for surface in part.getSurfaces():
if surface.getVisibility():
#_target.extend(surface.getEdges())
for Vertex in surface.getVertices():
listOfEdges = []
listOfLengths = []
for Edge in Vertex.getConnectedEdges():
listOfEdges.append(Edge.getId())
listOfLengths.append(Edge.getLength())
if len(listOfEdges) > 2:
sortedByHeight = [int(x) for _, x in sorted(zip(listOfLengths, listOfEdges))]
_target.append(surface.getEdge(id=sortedByHeight[0]))
"""
result = apex.geometry.suppressOnly(target=_target,
maxEdgeAngle=1.745329251994330e-01,
maxFaceAngle=8.726646259971650e-02,
keepVerticesAtCurvatureChange=False,
cleanupTol=1.000000000000000)
def ShowSurfMeshedOnly(dict={}):
#===================================================================
## Initializing Apex code
apex.setScriptUnitSystem(unitSystemName=r'''mm-kg-s-N''')
model_1 = apex.currentModel()
# ===================================================================
for Part in model_1.getParts(recursive=True):
if 'Trajectories' not in Part.getPathName():
_target = apex.entityCollection()
for Mesh in Part.getMeshes():
print(Mesh.entityType)
if Mesh.entityType == apex.EntityType.SurfaceMesh:
_target.extend(Part)
_target.hide()
def CreateMeshNONPartitions(dict={}):
#===================================================================
## Initializing Apex code
apex.setScriptUnitSystem(unitSystemName = r'''mm-kg-s-N''')
model_1 = apex.currentModel()
try:
MeshSize = float(dict["CoarseMeshSize"])
except:
MeshSize = float(dict["MeshSize"])
listOfAllParts = []
for Part in model_1.getParts(True):
if "Trajectories" not in Part.getPath():
listOfAllParts.append(Part)
## Getting all faces from all parts that are not under 'Trajectories'
listOfNonMeshedFaces = apex.EntityCollection()
for Part in listOfAllParts:
for Surface in Part.getSurfaces():
for Face in Surface.getFaces():
if not Face.getElements():
listOfNonMeshedFaces.append(Face)
## -----------------------------------------------------------------------------------------------------------
## -----------------------------------------------------------------------------------------------------------
apex.mesh.createSurfaceMesh(
name="",
target=listOfNonMeshedFaces,
meshSize= MeshSize,
meshType=apex.mesh.SurfaceMeshElementShape.Mixed,
meshMethod=apex.mesh.SurfaceMeshMethod.Pave,
mappedMeshDominanceLevel=0,
elementOrder=apex.mesh.ElementOrder.Linear,
meshUsingPrincipalAxes=False,
refineMeshUsingCurvature=True,
elementGeometryDeviationRatio=0.10,
elementMinEdgeLengthRatio=0.50,
createFeatureMeshOnFillets=False,
createFeatureMeshOnChamfers=False,
createFeatureMeshOnWashers=False,
createFeatureMeshOnQuadFaces=False
)
def SuppressFeatures(dict={}):
#===================================================================
## Initializing Apex code
apex.setScriptUnitSystem(unitSystemName=r'''mm-kg-s-N''')
model_1 = apex.currentModel()
_target = apex.entityCollection()
try:
for part in model_1.getParts(True):
if 'Trajectories' not in part.getPath():
for surface in part.getSurfaces():
_target.extend(surface.getEdges())
_target.extend(surface.getVertices())
result = apex.geometry.suppressOnly(
target=_target,
maxEdgeAngle=1.745329251994330e-01,
maxFaceAngle=8.726646259971650e-02,
keepVerticesAtCurvatureChange=False,
cleanupTol=1.000000000000000)
except:
print("Simplification not performed or failed.")
def SplitByTrajectories(dict={}):
apex.setScriptUnitSystem(unitSystemName=r'''mm-kg-s-N''')
model_1 = apex.currentModel()
try:
listOfParts = model_1.getParts(True)
_target = apex.entityCollection()
_face = apex.entityCollection()
for Part in listOfParts:
if 'Trajectories' in Part.getPath():
for Solid in Part.getSolids():
_face += Solid.getFaces()
else:
_target += Part.getSurfaces()
apex.geometry.splitOnSurface(
target=_target,
face=_face,
splitBehavior=apex.geometry.GeometrySplitBehavior.Partition)
entities_1 = apex.EntityCollection()
assembly_1 = model_1.getAssembly(pathName="Trajectories")
entities_1.append(assembly_1)
entities_1.hide()
except:
print("Split failed or not performed.")
def GenerateStudies(dict={}):
# ===================================================================
## Initializing Apex code
apex.setScriptUnitSystem(unitSystemName=r'''mm-kg-s-N''')
model_1 = apex.currentModel()
# Check existing material and create generic steel if needed
if "SteelGeneric" not in apex.catalog.getMaterialDictionary().keys():
apex.setScriptUnitSystem(unitSystemName=r'''m-kg-s-N''')
SteelMaterial = apex.catalog.createMaterial(name="SteelGeneric",
description="",
color=[64, 254, 250])
SteelMaterial.update(elasticModulus=210.e+9,
poissonRatio=0.3,
density=7.8e-6)
apex.setScriptUnitSystem(unitSystemName=r'''mm-kg-s-N''')
#print("Material data for generic steel created")
else:
#print("Material already exists, skipping...")
pass
# Assign generic steel material to all Parts
GenericMaterial = apex.catalog.getMaterial(name="SteelGeneric")
_target = apex.EntityCollection()
_target.extend(model_1.getParts(True))
apex.attribute.assignMaterial(material=GenericMaterial, target=_target)
# Run body selection
for selAssy in apex.selection.getCurrentSelection():
listOfRefSolid = []
listOfRefSolidPaths = []
for Part in selAssy.getParts(True):
Part.update(color=[255, 0, 0])
Part.show()
for Solid in Part.getSolids():
listOfRefSolidPaths.append(Solid.getPathName())
listOfRefSolid.append(Solid)
listOfTargetSolids = apex.EntityCollection()
for Part in model_1.getParts(True):
for Solid in Part.getSolids():
if Solid.getPathName() not in listOfRefSolidPaths:
listOfTargetSolids.append(Solid)
Solid.update(color=[0, 0, 255])
Part.addUserAttribute(userAttributeName=Part.getPathName(),
stringValue='Self')
for refSolid in listOfRefSolid:
textDisplay = apex.display.displayText(
text=refSolid.getName(),
textLocation=refSolid.getCentroid(),
graphicsFont="Calibri",
graphicsFontColor=apex.ColorRGB(255, 191, 0),
graphicsFontSize=16,
graphicsFontStyle=apex.display.GraphicsFontStyle.Normal,
graphicsFontUnderlineStyle=apex.display.
GraphicsFontUnderlineStyle.NoUnderline)
distance_ = apex.measureDistance(source=refSolid,
target=listOfTargetSolids)
listOfTouchedBodies = apex.EntityCollection()
try:
_ans = refSolid.getParent().removeUserAttributes(
userAttributeNames=[])
except:
pass
refSolid.getParent().addUserAttribute(
userAttributeName=refSolid.getParent().getPathName(),
stringValue='Self')
for k in range(len(distance_)):
if distance_[k] <= 0.0:
listOfTouchedBodies.append(listOfTargetSolids[k])
refSolid.getParent().addUserAttribute(
userAttributeName=listOfTargetSolids[k].getParent(
).getPathName(),
stringValue='Touched')
apex.display.clearAllGraphicsText()
# Organizing Parts and getting ready for modal analysis
for refSolid in listOfRefSolid:
StudyAssy = model_1.createAssembly(name="StudyAssy")
dictInfo = {"Self": "", "Touched": []}
solidParent = refSolid.getParent()
# Moving Parts to the StudyAssy
for Attribute in solidParent.getUserAttributes():
if Attribute.getStringValue() == 'Self':
dictInfo[Attribute.getStringValue(
)] = Attribute.getAttributeName()
else:
dictInfo[Attribute.getStringValue()].append(
Attribute.getAttributeName())
ans_ = apex.getPart(
Attribute.getAttributeName()).setParent(
parent=StudyAssy)
refSolid.getParent().setParent(parent=StudyAssy)
# Creating ties based on touching bodies
listOfTies = apex.EntityCollection()
BeadPath = StudyAssy.getPart(
dictInfo["Self"][dictInfo["Self"].rfind("/") +
1:]).getPathName()
for elem in dictInfo["Touched"]:
compPath = StudyAssy.getPart(elem[elem.rfind("/") +
1:]).getPathName()
_entities = apex.getEntities(pathNames=[BeadPath, compPath])
newTies = apex.attribute.createMeshIndependentTieAutomatic(
target=_entities,
tiePairTolerance=5.,
patchToleranceCalculationMethod=apex.AutoManual.Automatic)
listOfTies.extend(newTies)
# --- Running the modal thing
scenaryName = "Scenario for " + solidParent.getName()
context_ = StudyAssy
study = apex.getPrimaryStudy()
study.createScenario(
name=scenaryName,
description="Generated by the Optimization Toolbox - FO",
scenarioConfiguration=apex.studies.ScenarioConfiguration.
NormalModes)
study = apex.getPrimaryStudy()
scenario1 = study.getScenario(name=scenaryName)
scenario1.associateModelRep(context_)
# study = apex.getPrimaryStudy()
# scenario1 = study.getScenario(name=scenaryName)
# simSetting1 = scenario1.simulationSettings
# simSetting1.partReduction = False
# simSetting1.freqRangeLower = 1000.
# simSetting1.freqRangeUpper = float('NaN')
# simSetting1.stopCalculation = True
# simSetting1.maxModes = 3
# scenario1.simulationSettings = simSetting1
#model_1.save()
scenario1.execute() # Kick it
# --- Done with execution
# Deleting ties
apex.deleteEntities(listOfTies)
# Reset the model tree
for Part in StudyAssy.getParts(True):
for Attribute in Part.getUserAttributes():
if Attribute.getStringValue() == 'Self':
index = Attribute.getAttributeName().rfind("/")
ParentAssy = Attribute.getAttributeName()[0:index]
Part.setParent(parent=apex.getAssembly(ParentAssy))
# Delete the Assembly used to build the study
toDelete = apex.EntityCollection()
toDelete.append(StudyAssy)
apex.deleteEntities(toDelete)
# --- Do postprocessing
result = apex.session.displayMeshCracks(False)
result = apex.session.display2DSpans(False)
result = apex.session.display3DSpans(False)
apex.display.hideRotationCenter()
result = apex.session.displayMeshCracks(False)
result = apex.session.displayInteractionMarkers(True)
result = apex.session.displayConnectionMarkers(True)
result = apex.session.display2DSpans(False)
result = apex.session.display3DSpans(True)
result = apex.session.displayLoadsAndBCMarkers(True)
result = apex.session.displaySensorMarkers(True)
study = apex.getPrimaryStudy()
scenario1 = study.getScenario(name=scenaryName)
executedscenario_1 = scenario1.getLastExecutedScenario()
event1 = executedscenario_1.getEvent(
pathName="/Study/{0}<< -1>>/Event 1".format(scenaryName))
stateplot_1 = apex.post.createStatePlot(event=event1,
resultDataSetIndex=[7])
visualizationTarget1 = apex.entityCollection()
study = apex.getPrimaryStudy()
scenario1 = study.getScenario(name=scenaryName)
executedscenario_1 = scenario1.getLastExecutedScenario()
visualizationTarget1.append(
executedscenario_1.getAssembly(
pathName=apex.currentModel().name +
"/ar:StudyAssy_Default Rep"))
deformvisualization_1 = stateplot_1.createDeformVisualization(
target=visualizationTarget1,
deformScalingMethod=apex.post.DeformScalingMethod.Relative,
relativeScalingFactor=2.,
displayUnit="mm")
result = apex.session.displaySensorMarkers(False)
colormap_1 = apex.post.createColorMap(
name="FringeSpectrum",
colorMapSegmentMethod=apex.post.ColorMapSegmentMethod.Linear,
start=0.0,
end=0.0,
isLocked=False,
useOutOfRangeColors=False,
displayContinuousColors=False)
visualizationTarget1 = apex.entityCollection()
study = apex.getPrimaryStudy()
scenario1 = study.getScenario(name=scenaryName)
executedscenario_1 = scenario1.getLastExecutedScenario()
visualizationTarget1.append(
executedscenario_1.getAssembly(
pathName=apex.currentModel().name +
"/ar:StudyAssy_Default Rep"))
contourvisualization_1 = stateplot_1.createContourVisualization(
contourStyle=apex.post.ContourStyle.Fringe,
target=visualizationTarget1,
resultQuantity=apex.post.ResultQuantity.
DisplacementTranslational,
resultDerivation=apex.post.ResultDerivation.Magnitude,
layerIdentificationMethod=apex.post.LayerIdentificationMethod.
Position,
layers=["NONE"],
layerEnvelopingMethod=apex.post.LayerEnvelopingMethod.Unknown,
elementNodalProcessing=apex.post.ElementNodalProcessing.
Averaged,
coordinateSystemMethod=apex.post.CoordinateSystemMethod.Global,
colorMap=colormap_1,
displayUnit="mm")
contourvisualization_1.update()
result = apex.session.display3DSpans(False)
result = apex.session.displaySensorMarkers(True)
result = apex.session.display2DSpans(False)
result = apex.session.display3DSpans(False)
result = apex.session.displaySensorMarkers(True)
for i in range(4):
stateplot_1.update(resultDataSetIndex=[7 + i])
time.sleep(3)
capturedImage = apex.display.captureImage(
path=
r"D:\00-Projects\01-SequenceOptimization\ApexFiles\Images",
imageNamePrefix=scenaryName,
imageCaptureRegion=apex.display.CaptureRegionType.Viewport,
imageFormat=apex.display.ImageType.jpg)
apex.post.exitPostProcess()
def CreateSpots(dict={}):
from apex.construct import Point3D, Point2D
from math import sqrt, pow, degrees, acos, pi
import os
apex.setScriptUnitSystem(unitSystemName=r'''mm-kg-s-N''')
absPath = os.path.dirname(os.path.realpath(__file__))
### Math functions needed when numpy is not available
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 CreateSpotGroup(CSVPath="Path", RefineDiam=8.0):
model_1 = apex.currentModel()
if "/" in CSVPath:
TrajectoryName = CSVPath[CSVPath.rfind("/") + 1:-4]
else:
TrajectoryName = CSVPath[CSVPath.rfind("\\") + 1:-4]
try:
TrajAssy = model_1.getAssembly(pathName="Trajectories")
except:
TrajAssy = model_1.createAssembly(name="Trajectories")
WeldPositions = []
ScalingToMM = 1.0
with open(CSVPath, 'r') as CSVFile:
for line in CSVFile:
if "Length unit:" in line:
unit = line.strip().split('[')[-1].replace("]", "")
if unit == "mm":
ScalingToMM = 1.0
elif unit == "m":
ScalingToMM = 1000.0
elif uni == "in":
ScalingToMM = 25.40
if ('true' in line) or ('false' in line):
WeldPositions.append([
ScalingToMM * float(x)
for x in line.strip().split(';')[2:5]
])
for spotPoint in WeldPositions:
result = apex.geometry.createSphereByLocationOrientation(
name='',
description='',
radius=RefineDiam / 2.0,
origin=apex.Coordinate(spotPoint[0], spotPoint[1],
spotPoint[2]),
orientation=apex.construct.createOrientation(alpha=0.0,
beta=0.0,
gamma=0.0))
model_1.getCurrentPart().update(name=TrajectoryName)
ans = model_1.getCurrentPart().setParent(parent=TrajAssy)
try:
if model_1.getAssembly("Trajectories").getPart(
name="RefDiam_{0}".format(RefineDiam)):
pass
else:
SpecifiedDiameter = apex.createPart(
name="RefDiam_{0}".format(RefineDiam))
SpecifiedDiameter.setParent(
model_1.getAssembly("Trajectories"))
except:
print("Part creation failed!")
vecFiles = dict["FileList"][0:-1].split(',')
for file in vecFiles:
CreateSpotGroup(CSVPath=file, RefineDiam=float(dict["RefineDiameter"]))
def CreateMeshPartitions(dict={}):
# ===================================================================
## Initializing Apex code
apex.setScriptUnitSystem(unitSystemName=r'''mm-kg-s-N''')
model_1 = apex.currentModel()
## Collect faces to mesh
_targetFine = apex.entityCollection()
listOfLengths = []
listOfDiameters = []
try:
MeshSize = float(dict["MeshSize"])
except:
MeshSize = float(dict["FineMeshSize"])
#try:
listOfTrajectories = model_1.getAssembly("Refinement regions").getParts(
True)
listOfAllParts = []
for Part in model_1.getParts(True):
if "Refinement regions" not in Part.getPath():
listOfAllParts.append(Part)
for Part in listOfTrajectories:
if 'RefDiam' in Part.getName():
_, Diam = Part.getName().split('_')
listOfDiameters.append(float(Diam))
else:
if len(Part.getCurves()) > 0:
listOfLengths.append(Part.getCurves()[0].getLength())
maxDiameter = max(
listOfDiameters) #Getting the max diameter to use as search range
## Getting all faces from all parts that are not under 'Trajectories'
proxSearch = apex.utility.ProximitySearch()
listOfAllPartFaces = []
for Part in listOfAllParts:
for Surface in Part.getSurfaces():
for Face in Surface.getFaces():
listOfAllPartFaces.append(Face)
## Inserting the list of faces into the proximity search
ans = proxSearch.insertList(listOfAllPartFaces)
facesToMesh = apex.EntityCollection()
## Perform the search
for Part in model_1.getAssembly('Refinement regions').getParts(
): # Add spots and weld beads to perfom the search
for Solid in Part.getSolids():
resSearch = proxSearch.findObjectsWithinDistance(
location=Solid.getLocation(), distance=1.1 * maxDiameter)
for elem in resSearch.foundObjects():
if elem.entityType == apex.EntityType.Face:
facesToMesh.append(elem)
if listOfLengths:
minLength = min(listOfLengths)
## Select everything that is smaller than the minLength * maxDiameter
for Assy in model_1.getAssemblies():
if "Refinement regions" not in Assy.getName():
for Part in Assy.getParts(recursive=True):
for Surface in Part.getSurfaces():
for Face in Surface.getFaces():
if Face.getArea() <= (0.8 * max(listOfLengths) *
maxDiameter):
facesToMesh.append(Face)
else:
## Select everything that is smaller than the minLength * maxDiameter
for Part in listOfAllParts:
for Surface in Part.getSurfaces():
for Face in Surface.getFaces():
if Face.getArea() <= (1.1 * 3.14159 *
(maxDiameter / 2)**2):
facesToMesh.append(Face)
apex.mesh.createSurfaceMesh(
name="",
target=facesToMesh,
meshSize=MeshSize,
meshType=apex.mesh.SurfaceMeshElementShape.Mixed,
meshMethod=apex.mesh.SurfaceMeshMethod.Pave,
mappedMeshDominanceLevel=2,
elementOrder=apex.mesh.ElementOrder.Linear,
meshUsingPrincipalAxes=False,
refineMeshUsingCurvature=True,
elementGeometryDeviationRatio=0.10,
elementMinEdgeLengthRatio=0.50,
createFeatureMeshOnFillets=False,
createFeatureMeshOnChamfers=False,
createFeatureMeshOnWashers=False,
createFeatureMeshOnQuadFaces=False)
try:
pass
except:
print("Meshing failed or not performed.")
# pylint:disable=no-name-in-module, no-member, wrong-import-position
import os
import atexit
# ---------- Launch Apex NOTE: This must be done before import apex -----------
import remoting
remoting.launchApplication()
atexit.register(
remoting.shutdownApplication) # Close Apex if script terminates
# -----------------------------------------------------------------------------
import apex
# Import from local library
from library import truss_sketch, find_constraint_nodes, find_load_nodes, get_unused_name
# Define the units system
apex.setScriptUnitSystem(unitSystemName=r'''in-slinch-s-lbf''') #pylint:disable=no-member
# Define a directory for saving models
SAVE_DIRECTORY = os.path.join(os.getcwd(), 'model')
# Create the save directory if it doesn't exist
if os.path.exists(SAVE_DIRECTORY) is False:
os.mkdir(SAVE_DIRECTORY)
# Define the endpoints of the truss
TRUSS_ENDPOINTS = [(0, 0), (0, 100), (100, 0), (100, 100)]
def build_truss_model():
"""Builds a ready-to-solve model of a truss structure and saves the model.
def BeadBySweep(dict={}):
import apex
apex.disableShowOutput()
from apex.construct import Point3D, Point2D
from math import sqrt, pow, degrees, acos, pi
import os
apex.setScriptUnitSystem(unitSystemName=r'''mm-kg-s-N''')
### 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 CreateWeldBead(CSVPath="NoPath", RefineDiam=4.0, UnitType="None"):
model_1 = apex.currentModel()
if "/" in CSVPath:
TrajectoryName = CSVPath[CSVPath.rfind("/") + 1:-4]
else:
TrajectoryName = CSVPath[CSVPath.rfind("\\") + 1:-4]
try:
TrajAssy = model_1.getAssembly(pathName="Refinement regions")
except:
TrajAssy = model_1.createAssembly(name="Refinement regions")
CurrPart = apex.createPart(name=TrajectoryName)
CurrPart.setParent(model_1.getAssembly("Refinement regions"))
vecLine = []
with open(CSVPath, 'r') as CSVContent:
if UnitType == 'Millimeters':
convRatio = 1.0
elif UnitType == 'Meters':
convRatio = 1000.0
elif UnitType == 'Inches':
convRatio = 2.54
for line in CSVContent:
if ('true' in line) or ('false' in line):
vecLine.append([
convRatio * float(X)
for X in line.strip().split(';')[2:5]
])
## Creating points at the location in the CSV file, these will guide the spline creation
_iphysicalCollection = apex.IPhysicalCollection()
for i in range(len(vecLine)):
_iphysicalCollection.append(
apex.Coordinate(vecLine[i][0], vecLine[i][1], vecLine[i][2]))
## Create spline based on the list of points given by the CSV file
result = apex.geometry.createCurve(
target=_iphysicalCollection,
behavior=apex.geometry.CurveBehavior.Spline)
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='Sketch 1',
plane=apex.construct.GlobalPlane.YZ,
alignSketchViewWithViewport=True)
circle_1 = sketch_1.createCircleCenterPoint(
name="Circle 1",
centerPoint=Point2D(0, 0),
pointOnCircle=Point2D(0, diam / 2))
return sketch_1.completeSketch(fillSketches=True)
CircleDone = doCircle(diam=RefineDiam)
## Move circle to a new point location
part_2 = model_1.getCurrentPart()
for Surf in part_2.getSurfaces():
CurrPath = Surf.getPathName()
CurrPath = CurrPath[CurrPath.find('/') + 1:]
_entities = model_1.getEntities(pathNames=[CurrPath])
PathLength = sqrt(
pow(vecLine[0][0], 2) + pow(vecLine[0][1], 2) +
pow(vecLine[0][2], 2))
apex.transformTranslate(target=_entities,
direction=vecLine[0],
distance=PathLength,
makeCopy=False)
## Rotate the circle
_entities = model_1.getEntities(pathNames=[CurrPath])
TurnAngle = angle([1, 0, 0],
[a - b for a, b in zip(vecLine[1], vecLine[0])])
if TurnAngle == 180:
TurnAngle = 0
apex.transformRotate(
target=_entities,
axisDirection=cross(
[1, 0, 0], [a - b for a, b in zip(vecLine[1], vecLine[0])]),
axisPoint=Point3D(vecLine[0][0], vecLine[0][1], vecLine[0][2]),
angle=TurnAngle,
makeCopy=False)
_target = apex.EntityCollection()
_target.append(model_1.getCurrentPart().getSurfaces()[0])
_path = apex.EntityCollection()
_path.append(model_1.getCurrentPart().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)
GotBead = True
except:
print("Sweep failed...")
GotBead = False
## Clean up the supporting geometries (points, curves, surfaces, etc.)
DelEntities = apex.EntityCollection()
## Do NOT delete curves, they are used to get weld bead length
"""
DelCurves = model_1.getCurrentPart().getCurves()
for Curve in DelCurves:
DelEntities.append(Curve)
DelPoints = model_1.getCurrentPart().getPoints()
for Point in DelPoints:
DelEntities.append(Point)
"""
if GotBead:
DelSurfaces = model_1.getCurrentPart().getSurfaces()
for Surface in DelSurfaces:
DelEntities.append(Surface)
apex.deleteEntities(DelEntities)
## Rename part and solid
if GotBead:
updateSolidName = model_1.getCurrentPart().getSolids()[0].update(
name=TrajectoryName)
if dict["ExtendBead"] == "True": #Push-pull the extremities by the diameter amount
try:
for Face in model_1.getCurrentPart().getSolids(
)[0].getFaces():
XSectionArea = 3.14159 * (RefineDiam / 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=RefineDiam,
direction=[1.0, 1.0, 1.0])
except:
updatePartName = model_1.getCurrentPart().update(
name=TrajectoryName + "_ExtendFailed")
else:
updatePartName = model_1.getCurrentPart().update(
name=TrajectoryName + "_SweepFailed")
try:
if model_1.getAssembly("Refinement regions").getPart(
name="RefDiam_{0}".format(RefineDiam)):
pass
else:
SpecifiedDiameter = apex.createPart(
name="RefDiam_{0}".format(RefineDiam))
SpecifiedDiameter.setParent(
model_1.getAssembly("Refinement regions"))
except:
print("Part creation failed!")
#print(len(dict["FileList"]))
vecFiles = dict["FileList"][0:-1].split(',')
for file in vecFiles:
CreateWeldBead(CSVPath=file,
RefineDiam=float(dict["BeadLeg"]) * 2,
UnitType=dict["unitType"])
import apex
from apex.construct import Point3D, Point2D
apex.disableShowOutput()
apex.setScriptUnitSystem(unitSystemName=r'''mm-kg-s-N''')
model_1 = apex.currentModel()
def RemoveEmpty(dict={}):
entitiesToRemove = apex.EntityCollection()
for Part in model_1.getParts(True):
if not Part.getSolids():
entitiesToRemove.append(Part)
try:
apex.deleteEntities(entitiesToRemove)
except:
pass
entitiesToRemove = apex.EntityCollection()
for Assy in model_1.getAssemblies(True):
if not Assy.getParts(True):
entitiesToRemove.append(Assy)
try:
apex.deleteEntities(entitiesToRemove)
except:
pass
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))
