def ElementInfolisteErstellen(elemente, knoten, listenhilfe=[]):
"""Erstelle eine Hilfsliste mit Punktkoordinaten und Volumina aller uebergebenen elemente. Dazu
wird neben elemente eine Liste aller Punktkoordinaten (knoten) benoetigt. Die optionale
Uebergabe einer Zuordnung listenhilfe von Labels zu Indizes beschleunigt den Vorgang.
Gibt elementinfoliste zurueck.
WICHTIG: Wenn Elemente einer mdb statt einer odb untersucht werden sollen, sollte entweder keine
oder die folgende listenhilfe uebergeben werden:
listenhilfe = [idx for idx in range(len(knoten))];
"""
from hilfen import ElementAusOdb, ErstelleLabelsortierteGeomlist
#
if (listenhilfe == []):
if (ElementAusOdb(element=elemente[0])):
listenhilfe = ErstelleLabelsortierteGeomlist(geomliste=knoten)
else:
listenhilfe = [idx for idx in range(len(knoten))]
#
elementinfoliste = []
dimensionen = 2
if ('3D' in str(elemente[0].type)):
dimensionen = 3
#
for idx, elem in enumerate(elemente):
punkte = PunktkoordinatenVonElement(element=elem,
knoten=knoten,
listenhilfe=listenhilfe)
elementinfoliste += [[
punkte,
ElementVolumen(punkte=punkte, dimensionen=dimensionen)
]]
#
return elementinfoliste
def KnotengewichtungInElement(element, referenzpunkt, knoten, label_zu_idx_punkte=[]):
"""Bestimmt die Anteile, die ein referenzpunkt aus den Knotenpunkten des in punkte definierten
Elements hat. Die Koordinaten der Elemente muessen in knoten definiert sein. Die optionale
Uebergabe einer Zuordnung Listenhilfe von Labels zu Indizes beschleunigt den Vorgang.
Gibt [labelsEckpunkte, Knotengewichtung] zurueck.
WICHTIG: Wenn Elemente einer mdb statt einer odb untersucht werden sollen, sollte entweder keine
oder die folgende label_zu_idx_punkte uebergeben werden:
label_zu_idx_punkte = [idx for idx in range(len(knoten))];
"""
from hilfen import ElementAusOdb, ErstelleLabelsortierteGeomlist
#
if (label_zu_idx_punkte == []):
if (ElementAusOdb(element=element)):
label_zu_idx_punkte = ErstelleLabelsortierteGeomlist(geomliste=knoten);
else:
label_zu_idx_punkte = [idx for idx in range(len(knoten))];
#
dimensionen = 2;
if ('3D' in str(element.type)):
dimensionen = 3;
#
punkte = PunktkoordinatenVonElement(element=element, knoten=knoten,
listenhilfe=label_zu_idx_punkte);
punktlabels = [knoten[label_zu_idx_punkte[einzelpunkt]].label for einzelpunkt in element.connectivity];
return [punktlabels, KnotengewichtungPunktInPunktkoordinaten(punkte=punkte,
referenzpunkt=referenzpunkt, dimensionen=dimensionen)];
def _ZustandsuebertragungOdbVorbereiten(dimensionen, odbknoten, odbelemente):
"""Formatiere Ausgabedaten (odbknoten, odbelemente) fuer die externe Bibliothek zur
Zustandsuebertragung. Gibt [cpp_odbknoten, cpp_odbelemente] zurueck.
"""
from ctypes import c_double, c_int
from hilfen import ErstelleLabelsortierteGeomlist
#
# Von der externen Bibliothek werden die Knoten-Daten als Array im folgenden Format erwartet:
# [P0x, P0y, (P0z, ) P1x, P1y, (P1z, ), ...]
# also sortiert nach den Punkten und fuer jeden Punkt alle Koordianten beginnend mit der
# x-Koordinate. Die Anzahl an Koordinaten entspricht dimensionen und die Anzahl an Eckpunkten
# ist in den knoten_pro_...element-Variablen gespeichert
# Die Element-Daten werden als Array im folgenden Format erwartet:
# [L0_P0, L0_P1, L0_P2, (L0_P3, L0_P4, L0_P5, L0_P6, L0_P7), L1_P0, L1_P1, L1_P2, ...]
# also sortiert nach den Elementen und fuer jedes Element die Labels aller Eckpunkte (fuer
# Vierecke und Hexahedrons in der passenden Reihenfolge).
#
# Fuer odbknoten und odbelemente kann die Sortierung der Label relativ beliebig sein.
# Deshalb wird ein labelsortiertes Dict erstellt, um von den Labels auf die dazugehoerigen
# Indizes zuweisen zu koennen. Die Labels starten zusaetzlich bei 1 statt bei 0.
knoten_pro_odbelement = len(odbelemente[0].connectivity);
listenhilfe_odbknoten = ErstelleLabelsortierteGeomlist(geomliste=odbknoten);
mod_odbknoten = [0.0 for idx in range(int(dimensionen*len(odbknoten)))];
for label_knoten in range(0, len(odbknoten)):
zielKnoten = odbknoten[listenhilfe_odbknoten[label_knoten+1]];
for achse in range(dimensionen):
mod_odbknoten[dimensionen*label_knoten+achse] = zielKnoten.coordinates[achse];
#
DoubleArray_odbknoten = c_double * len(mod_odbknoten);
cpp_odbknoten = DoubleArray_odbknoten(*list(mod_odbknoten));
#
listenhilfe_odbelemente = ErstelleLabelsortierteGeomlist(geomliste=odbelemente);
mod_odbelemente = [0 for idx in range(int(knoten_pro_odbelement*len(odbelemente)))];
for label_elemente in range(len(odbelemente)):
zielElement = odbelemente[listenhilfe_odbelemente[label_elemente+1]];
for idx_eckpunkt in range(knoten_pro_odbelement):
# Da im Folgenden die Indizes und nicht die Label betrachtet werden,
# und die Labels mit 1 statt Null starten, ziehe Eins ab
mod_odbelemente[knoten_pro_odbelement*label_elemente+idx_eckpunkt] = zielElement.connectivity[idx_eckpunkt]-1;
#
IntArray_odbelemente = c_int * len(mod_odbelemente);
cpp_odbelemente = IntArray_odbelemente(*list(mod_odbelemente));
#
return [cpp_odbknoten, cpp_odbelemente];
def ElementAuswahlLabelliste(elemente, punktliste, sortierung=0, aufsteigend=True,
listenhilfe=[]):
"""Sortiert alle uebergebenen elemente nach der Koordinatenrichtung sortierung basierend auf den
Koordinaten des Elementmittelpunktes. Fuer die Berechnung der Mittelpunktkoordinaten werden die
Knoten der Elemente benutzt. Fuer die Zuordnung der einzelnen Punkte zu den Elementen muss eine
punktliste uebergeben werden, die alle Punkte aller elemente enthaelt. Gibt eine Liste der Labels
aller uebergebenen elemente zurueck, deren Mittelpunkte nach der Koordinatenrichtung sortierung
sortiert ist.
Fuer die sortierung ist die jeweilige Richtung (0, 1 oder 2) anzugeben. Die Reihenfolge wird
ueber die Koordinaten der Mittelpunkte der Elemente bestimmt. Die Werte koennen entweder
aufsteigend oder absteigend sortiert werden.
Optional kann die korrekte Zuordnung der Labels der Punkte bei odb-elementen durch Uebergabe
einer listenhilfe beschleunigt werden.
WICHTIG: Wenn Elemente einer mdb statt einer odb untersucht werden sollen, sollte entweder keine
oder die folgende listenhilfe uebergeben werden:
listenhilfe = [idx for idx in range(len(punktliste))];
"""
from operator import itemgetter
from hilfen import Log, ElementAusOdb, ErstelleLabelsortierteGeomlist
#
tempsortierung = sortierung;
if ((not (sortierung == 0)) and (not (sortierung == 1)) and (not (sortierung == 2))):
Log('# Warnung: Ungueltige sortierung, nehme sortierung = 0');
tempsortierung = 0;
#
if (len(elemente) == 0):
Log('# Hinweis: Keine Elemente uebergeben');
return [];
#
if (listenhilfe == []):
if (ElementAusOdb(element=elemente[0])):
listenhilfe = ErstelleLabelsortierteGeomlist(geomliste=punktliste);
else:
listenhilfe = [idx for idx in range(len(punktliste))];
#
templiste = [];
anzahlpunkte = float(len(elemente[0].connectivity));
for elem in elemente:
mittelwert = 0;
for punktlabel in elem.connectivity:
punkt = punktliste[listenhilfe[punktlabel]];
mittelwert = punkt.coordinates[tempsortierung]/anzahlpunkte;
#
templiste += [(mittelwert, elem.label), ];
#
templiste.sort(key=itemgetter(0));
labelliste = [x[1] for x in templiste];
if (aufsteigend):
return labelliste;
else:
return list(reversed(labelliste));
def PunktInElement(elemente, knoten, referenzpunkt, listenhilfe=[], elementinfoliste=[]):
"""Gebe den Label des Elements aus elemente zurueck, das referenzpunkt enthaelt. Die
Koordinaten der elemente muessen in knoten definiert sein. Die optionale Uebergabe einer
Zuordnung listenhilfe von Labels zu Indizes beschleunigt den Vorgang. Falls eine elementinfoliste
mit den Volumina und Punktkoordinaten aller Elemente verfuegbar ist, kann ebenfalls eine kleine
Beschleunigung erzielt werden. Gibt zielElement zurueck.
WICHTIG: Wenn Elemente einer mdb statt einer odb untersucht werden sollen, sollte entweder keine
oder die folgende listenhilfe uebergeben werden:
listenhilfe = [idx for idx in range(len(knoten))];
"""
from hilfen import Log, ElementAusOdb, ErstelleLabelsortierteGeomlist
#
if (listenhilfe == []):
if (ElementAusOdb(element=elemente[0])):
listenhilfe = ErstelleLabelsortierteGeomlist(geomliste=knoten);
else:
listenhilfe = [idx for idx in range(len(knoten))];
#
zielElement = None;
minverhaeltnis = 2.0;
dimensionen = 2;
if ('3D' in str(elemente[0].type)):
dimensionen = 3;
#
if (elementinfoliste == []):
for elem in elemente:
punkte = PunktkoordinatenVonElement(element=elem, knoten=knoten, listenhilfe=listenhilfe);
if (not _PunktMoeglicherweiseInElement(punkte=punkte, referenzpunkt=referenzpunkt,
dimensionen=dimensionen)):
continue;
#
volverhaeltnis = _PunktInnerhalbElement(punkte=punkte, referenzpunkt=referenzpunkt,
dimensionen=dimensionen);
if (volverhaeltnis < minverhaeltnis):
zielElement = elem.label;
minverhaeltnis = volverhaeltnis;
else:
if (not len(elemente) == len(elementinfoliste)):
Log('# Abbruch: Anzahl Elemente stimmt nicht mit Eintraegen in Elementlist ueberein');
return zielElement;
for idx, elem in enumerate(elemente):
if (not _PunktMoeglicherweiseInElement(punkte=elementinfoliste[idx][0],
referenzpunkt=referenzpunkt, dimensionen=dimensionen)):
continue;
#
referenzpunktvol = _ElementZuReferenzpunktVolumen(punkte=elementinfoliste[idx][0],
referenzpunkt=referenzpunkt, dimensionen=dimensionen);
volverhaeltnis = referenzpunktvol/elementinfoliste[idx][1];
if (volverhaeltnis < minverhaeltnis):
zielElement = elem.label;
minverhaeltnis = volverhaeltnis;
#
return zielElement;
def _OdbElementAuswahl(elemente,
punktliste,
bedingung='True',
var=[],
listenhilfe=[]):
"""Gib eine Sequenz an Elementen aus den uebergebenen elemente zurueck, die bzw. deren Punkte die
bedingung erfuellen (nur odb). Fuer die Zuordnung der einzelnen Punkte zu den Elementen muss eine
punktliste uebergeben werden, die alle Punkte aller elemente enthaelt. Die korrekte Zuordnung der
Labels der Punkte kann durch Uebergabe einer listenhilfe beschleunigt werden.
Gibt die Sequenz der ausgewaehlten Elemente zurueck.
In der Bedingung kann mit elem auf ein einzelnes Element und mit punkt auf einen Punkt des
Elements zugegriffen werden. Die Koordinaten eines Punktes koennen mit punkt.coordinates[#]
erhalten werden, wobei die Raute fuer 0, 1 oder 2 und somit eine der drei Bezugsrichtungen steht.
"""
from math import pi, sqrt, sin, cos, tan, asin, acos, atan
from hilfen import Log, _Eval_Basispruefung, ErstelleLabelsortierteGeomlist
#
ausgewaehlteElemente = elemente[0:0]
erlaubt = [
'coordinates', 'connectivity', 'featureName', 'index', 'instanceName',
'instanceNames', 'isReferenceRep', 'pointOn', 'sectionCategory',
'label', 'type', 'var', 'elem', 'punkt'
]
#
if (not _Eval_Basispruefung(code=bedingung, zusatz_erlaubt=erlaubt)):
Log('# Abbruch: Uebergebene bedingung ist ungueltig')
return ausgewaehlteElemente
#
if (listenhilfe == []):
listenhilfe = ErstelleLabelsortierteGeomlist(geomliste=punktliste)
#
numPunkte = len(elemente[0].connectivity)
for idx, elem in enumerate(elemente):
numErfuellt = 0
for punktlabel in elem.connectivity:
punkt = punktliste[listenhilfe[punktlabel]]
if (eval(bedingung)):
numErfuellt += 1
else:
continue
#
if (numErfuellt == numPunkte):
ausgewaehlteElemente += elemente[idx:idx + 1]
#
return ausgewaehlteElemente
def LabelAuswahl(elemente, labelliste, elementhilfsliste=[]):
"""Erstelle eine Sequenz aller uebergebener elemente, deren Label sich in labelliste befindet.
Optional kann eine elementhilfsliste vorab erzeugt und uebergeben werden, was vorallem bei
mehrmaligen Aufrufen einer LabelAuswahl fuer gleiche elemente deutlich schneller ist.
Falls keine elementhilfsliste uebergeben worden ist, wird (jedes mal) intern eine erstellt.
Gibt die Sequenz der ausgewaehlten Elemente zurueck.
"""
from hilfen import ErstelleLabelsortierteGeomlist
#
if (elementhilfsliste == []):
elementhilfsliste = ErstelleLabelsortierteGeomlist(geomliste=elemente);
#
ausgewaehlteElemente = elemente[0:0];
for label in labelliste:
idxelem = elementhilfsliste[label];
ausgewaehlteElemente += elemente[idxelem:idxelem+1];
#
return ausgewaehlteElemente;