def Quader_flaechensets(modell, name, laenge, breite, hoehe):
"""Erzeuge Flaechensets an der Oberseite, Unterseite und allen Seiten des Quaderbauteils (Part)
name im modell. Zur richtigen Zuordnung werden die Abmessungen laenge, breite und hoehe des
Quaders benoetigt. laenge und breite koennen entweder als Zahlenwert für eine symmetrische
Anordnung um den Ursprung (-zahl/2.0, zahl/2.0) oder direkt als (startpunkt, endpunkt) uebergeben
werden. Die hoehe wird als Zahlenwert erwartet und immer von Null an gestartet.
"""
import part
from auswahl import BedingteAuswahl
from hilfen import abapys_tol
#
laenge, breite = _Quader_Einheitliche_Geometrieangaben(laenge=laenge,
breite=breite)
partQuader = modell.parts[name]
#
flaechen_Unterseite = BedingteAuswahl(
elemente=partQuader.faces,
bedingung='elem.pointOn[0][2] < var[0]',
var=[abapys_tol])
partQuader.Set(name='setUnterseite', faces=flaechen_Unterseite)
flaechen_Oberseite = BedingteAuswahl(
elemente=partQuader.faces,
bedingung='elem.pointOn[0][2] > var[0]-var[1]',
var=[hoehe, abapys_tol])
partQuader.Set(name='setOberseite', faces=flaechen_Oberseite)
#
flaechen_X = BedingteAuswahl(
elemente=partQuader.faces,
bedingung=
'((elem.pointOn[0][0] < var[0]+var[2]) or (elem.pointOn[0][0] > var[1]-var[2]))',
var=[laenge[0], laenge[1], abapys_tol])
partQuader.Set(name='setXFlaeche', faces=flaechen_X)
flaechen_Y = BedingteAuswahl(
elemente=partQuader.faces,
bedingung=
'((elem.pointOn[0][1] < var[0]+var[2]) or (elem.pointOn[0][1] > var[1]-var[2]))',
var=[breite[0], breite[1], abapys_tol])
partQuader.Set(name='setYFlaeche', faces=flaechen_Y)
def Kugel(modell,
name,
radius,
materialtyp,
gittergroesse,
rp=False,
extrasets=False,
r_innen=[]):
"""Erzeuge eine Kugel name im modell mit dem uebergebenem radius vom Typ materialtyp
(Abaqus-Konstante, bspw. DEFORMABLE_BODY) und der Netzgroesse gittergroesse (Zahlenwert).
Optional kann ein Referenzpunkt rp oder extrasets erstellt werden. Optional kann ausserdem statt
einer Vollkugel eine Hohlkugel erzeugt werden, wenn r_innen gegeben ist.
Gibt [part<name>, inst<name>] zurueck.
"""
import part
import assembly
from abaqusConstants import TET, FREE, ON
from auswahl import BedingteAuswahl
from hilfen import abapys_tol
#
Kugel_erstellen(modell=modell,
name=name,
radius=radius,
materialtyp=materialtyp,
r_innen=r_innen)
partKugel = modell.parts[name]
Grundkoerper_standardpartitionen(modell=modell, name=name, rp=rp)
Grundkoerper_sets(modell=modell, name=name)
if (extrasets):
flaechen_Mantel = BedingteAuswahl(
elemente=partKugel.faces,
bedingung=
'sqrt(elem.pointOn[0][0]**2 + elem.pointOn[0][1]**2 + elem.pointOn[0][2]**2)) > var[0]-var[1]',
var=[radius, abapys_tol])
partKugel.Set(name='setMantelflaeche', faces=flaechen_Mantel)
#
# FIXME: Immer notwendig, Kugeln als TET zu diskretisieren?
partKugel.setMeshControls(elemShape=TET,
regions=partKugel.cells,
technique=FREE)
Grundkoerper_vernetzen(modell=modell,
name=name,
materialtyp=materialtyp,
gittergroesse=gittergroesse)
#
instname = 'inst' + name
modell.rootAssembly.Instance(dependent=ON, name=instname, part=partKugel)
return [partKugel, modell.rootAssembly.instances[instname]]
def Zylinder_flaechensets(modell, name, radius, hoehe, r_innen=[], viertel=4):
"""Erzeuge Flaechensets an der Oberseite, Unterseite und Mantel des Zylinderbauteils (Part) name
im modell. Zur richtigen Zuordnung werden radius und hoehe des Zylinders benoetigt. Falls nur ein
Viertel-/Halbzylinder erzeugt werden soll, werden zusaetzliche Sets erstellt.
"""
import part
from auswahl import BedingteAuswahl
from hilfen import abapys_tol
#
partZylinder = modell.parts[name]
#
flaechen_Unterseite = BedingteAuswahl(
elemente=partZylinder.faces,
bedingung='elem.pointOn[0][2] < var[0]',
var=[abapys_tol])
partZylinder.Set(name='setUnterseite', faces=flaechen_Unterseite)
flaechen_Oberseite = BedingteAuswahl(
elemente=partZylinder.faces,
bedingung='elem.pointOn[0][2] > var[0]-var[1]',
var=[hoehe, abapys_tol])
partZylinder.Set(name='setOberseite', faces=flaechen_Oberseite)
#
flaechen_Mantel = BedingteAuswahl(
elemente=partZylinder.faces,
bedingung=
'sqrt(elem.pointOn[0][0]**2 + elem.pointOn[0][1]**2) > var[0]-var[1]',
var=[radius, abapys_tol])
partZylinder.Set(name='setMantelflaeche', faces=flaechen_Mantel)
if ((viertel == 1) or (viertel == 2)):
if (viertel == 1):
flaechen_Y = BedingteAuswahl(
elemente=partZylinder.faces,
bedingung='(elem.pointOn[0][1] < var[0])',
var=[abapys_tol])
partZylinder.Set(name='setYFlaeche', faces=flaechen_Y)
#
flaechen_X = BedingteAuswahl(elemente=partZylinder.faces,
bedingung='(elem.pointOn[0][0] < var[0])',
var=[abapys_tol])
partZylinder.Set(name='setXFlaeche', faces=flaechen_X)
#
if (not r_innen == []):
flaechen_Mantelinnen = BedingteAuswahl(
elemente=partZylinder.faces,
bedingung=
'sqrt(elem.pointOn[0][0]**2 + elem.pointOn[0][1]**2) < var[0]+var[1]',
var=[r_innen, abapys_tol])
partZylinder.Set(name='setMantelinnen', faces=flaechen_Mantelinnen)
def _ConnectorErstellen(modell, verbindungstyp, name, punkt1, punkt2, kos):
"""Erzeuge im modell einen Connector name von punkt1 zu punkt2 mit dem Koordinatensystem kos. Je
nach verbindungstyp werden gewisse Einschraenkungen der Freiheitsgrade - bezogen auf das
uebergebene KOS (!) - fest zugewiesen:
- 'TranslateConnector': Beim Axiallager ist nur eine Verschiebung entlang der x-Achse moeglich.
- 'HingeConnector': Beim Drehscharnier ist nur eine Drehung um die x-Achse moeglich.
"""
import section
import assembly
from abaqusConstants import TRANSLATOR, HINGE, IMPRINT
from auswahl import BedingteAuswahl
from hilfen import Log
#
if (verbindungstyp == 'TranslateConnector'):
if (not modell.sections.has_key('TranslateConnector')):
modell.ConnectorSection(assembledType=TRANSLATOR,
name='TranslateConnector')
#
elif (verbindungstyp == 'HingeConnector'):
if (not modell.sections.has_key('HingeConnector')):
modell.ConnectorSection(assembledType=HINGE, name='HingeConnector')
else:
Log('# Warnung: Connector nicht implementiert')
#
modell.rootAssembly.WirePolyLine(mergeType=IMPRINT,
meshable=False,
points=((punkt1, punkt2), ))
modell.rootAssembly.features.changeKey(fromName='Wire-1', toName=name)
#
KabelKanten = BedingteAuswahl(elemente=modell.rootAssembly.edges,
bedingung='elem.featureName == \'' + name +
'\'')
modell.rootAssembly.Set(edges=KabelKanten, name='set' + name)
#
modell.rootAssembly.SectionAssignment(
sectionName=verbindungstyp,
region=modell.rootAssembly.sets['set' + name])
modell.rootAssembly.ConnectorOrientation(
localCsys1=kos, region=modell.rootAssembly.sets['set' + name])
def _Bohrprofil_partitionieren(modell,
name,
spitzenwinkel,
partitionsradius=None):
"""Erstelle Datums und Partitionen eines Bohrprofils am Bauteil (Part) name
im modell mit dem uebergebenem spitzenwinkel.
Optional kann das Gewinde bei einem uebergebenem partitionsradius partitioniert werden.
"""
import sketch
import part
from abaqusConstants import XAXIS, YAXIS, ZAXIS, XYPLANE, COPLANAR_EDGES, SIDE2, RIGHT
from auswahl import BedingteAuswahl
from zeichnung import Kreis
#
partWerkzeug = modell.parts[name]
# Datums
partWerkzeug.DatumAxisByPrincipalAxis(principalAxis=XAXIS)
partWerkzeug.features.changeKey(fromName='Datum axis-1', toName='xAchse')
xachsenid = partWerkzeug.features['xAchse'].id
partWerkzeug.DatumAxisByPrincipalAxis(principalAxis=YAXIS)
partWerkzeug.features.changeKey(fromName='Datum axis-1', toName='yAchse')
yachsenid = partWerkzeug.features['yAchse'].id
partWerkzeug.DatumAxisByPrincipalAxis(principalAxis=ZAXIS)
partWerkzeug.features.changeKey(fromName='Datum axis-1', toName='zAchse')
zachsenid = partWerkzeug.features['zAchse'].id
#
partWerkzeug.DatumPointByCoordinate(coords=(0.0, 0.0, 0.0))
partWerkzeug.features.changeKey(fromName='Datum pt-1',
toName='datum_Spitzenaufsatz')
datumbeginnid = partWerkzeug.features['datum_Spitzenaufsatz'].id
# Partitionen
if (partWerkzeug.features.has_key('datum_Gewindeende')):
# Pfahltyp SOBP
if (spitzenwinkel > 0.0):
partWerkzeug.PartitionCellByPlanePointNormal(
cells=partWerkzeug.cells,
normal=partWerkzeug.datums[zachsenid],
point=partWerkzeug.datums[datumbeginnid])
datumendeid = partWerkzeug.features['datum_Gewindeende'].id
partWerkzeug.PartitionCellByPlanePointNormal(
cells=partWerkzeug.cells,
normal=partWerkzeug.datums[zachsenid],
point=partWerkzeug.datums[datumendeid])
# Zellen vor und nach Gewinde (falls existent)
zellenOhneGewindebereich = BedingteAuswahl(
elemente=partWerkzeug.cells,
bedingung=
'(elem.pointOn[0][2] > var[0]) or (elem.pointOn[0][2] < var[1])',
var=[
partWerkzeug.features['datum_Gewindeende'].zValue,
partWerkzeug.features['datum_Spitzenaufsatz'].zValue
])
if (not zellenOhneGewindebereich == ()):
partWerkzeug.PartitionCellByPlanePointNormal(
cells=zellenOhneGewindebereich,
normal=partWerkzeug.datums[xachsenid],
point=partWerkzeug.datums[datumbeginnid])
zellenOhneGewindebereich = BedingteAuswahl(
elemente=partWerkzeug.cells,
bedingung=
'(elem.pointOn[0][2] > var[0]) or (elem.pointOn[0][2] < var[1])',
var=[
partWerkzeug.features['datum_Gewindeende'].zValue,
partWerkzeug.features['datum_Spitzenaufsatz'].zValue
])
partWerkzeug.PartitionCellByPlanePointNormal(
cells=zellenOhneGewindebereich,
normal=partWerkzeug.datums[yachsenid],
point=partWerkzeug.datums[datumbeginnid])
if ((not partWerkzeug.features.has_key('datum_Gewindeendea'))
and (not (partitionsradius is None))):
# SOBP
# Zellen auf dem Gewinde abtrennen
partWerkzeug.DatumPlaneByPrincipalPlane(offset=0.0,
principalPlane=XYPLANE)
partWerkzeug.features.changeKey(fromName='Datum plane-1',
toName='XYEbene')
xyebeneid = partWerkzeug.features['XYEbene'].id
modell.ConstrainedSketch(
gridSpacing=0.01,
name='__profile__',
sheetSize=0.6,
transform=partWerkzeug.MakeSketchTransform(
sketchPlane=partWerkzeug.datums[xyebeneid],
sketchPlaneSide=SIDE2,
sketchUpEdge=partWerkzeug.datums[yachsenid],
sketchOrientation=RIGHT,
origin=(0.0, 0.0, 0.0)))
zeichnung = modell.sketches['__profile__']
partWerkzeug.projectReferencesOntoSketch(filter=COPLANAR_EDGES,
sketch=zeichnung)
Kreis(zeichnung=zeichnung,
mittelpunkt=(0.0, 0.0),
radius=partitionsradius)
partWerkzeug.PartitionFaceBySketchThruAll(
faces=partWerkzeug.faces,
sketch=zeichnung,
sketchPlane=partWerkzeug.datums[xyebeneid],
sketchPlaneSide=SIDE2,
sketchUpEdge=partWerkzeug.datums[yachsenid])
del zeichnung
else:
# Alle Pfahltypen ausser SOBP und VVBP
partWerkzeug.PartitionCellByPlanePointNormal(
cells=partWerkzeug.cells,
normal=partWerkzeug.datums[xachsenid],
point=partWerkzeug.datums[datumbeginnid])
partWerkzeug.PartitionCellByPlanePointNormal(
cells=partWerkzeug.cells,
normal=partWerkzeug.datums[zachsenid],
point=partWerkzeug.datums[datumbeginnid])
if (spitzenwinkel > 0.0):
partWerkzeug.PartitionCellByPlanePointNormal(
cells=partWerkzeug.cells,
normal=partWerkzeug.datums[yachsenid],
point=partWerkzeug.datums[datumbeginnid])
# VVBP mit Vorlaufgewinde
if (partWerkzeug.features.has_key('datum_Gewindeendea')):
datumendeid = partWerkzeug.features['datum_Gewindeendea'].id
partWerkzeug.PartitionCellByPlanePointNormal(
cells=partWerkzeug.cells,
normal=partWerkzeug.datums[zachsenid],
point=partWerkzeug.datums[datumendeid])
# VVBP mit Ruecklaufgewinde
if (partWerkzeug.features.has_key('datum_Gewindeendeb')):
datumendeid = partWerkzeug.features['datum_Gewindeendeb'].id
partWerkzeug.PartitionCellByPlanePointNormal(
cells=partWerkzeug.cells,
normal=partWerkzeug.datums[zachsenid],
point=partWerkzeug.datums[datumendeid])
# VVBP mit Anfang Verdickung
if (partWerkzeug.features.has_key('datum_Profilendea')):
datumendeid = partWerkzeug.features['datum_Profilendea'].id
partWerkzeug.PartitionCellByPlanePointNormal(
cells=partWerkzeug.cells,
normal=partWerkzeug.datums[zachsenid],
point=partWerkzeug.datums[datumendeid])
# VVBP mit Ende Verdickung
if (partWerkzeug.features.has_key('datum_Profilendeb')):
datumendeid = partWerkzeug.features['datum_Profilendeb'].id
partWerkzeug.PartitionCellByPlanePointNormal(
cells=partWerkzeug.cells,
normal=partWerkzeug.datums[zachsenid],
point=partWerkzeug.datums[datumendeid])