From: GERALD NICOLAS Date: Thu, 1 Apr 2021 14:19:17 +0000 (+0200) Subject: Amélioration du ptyhon X-Git-Tag: V9_7_0a1~9^2~4 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=f44efbc02056a2734440b736789b8cfa380430bb;p=modules%2Fsmesh.git Amélioration du ptyhon --- diff --git a/src/Tools/blocFissure/gmu/__init__.py b/src/Tools/blocFissure/gmu/__init__.py index 5fc8fa53a..69bfe8200 100644 --- a/src/Tools/blocFissure/gmu/__init__.py +++ b/src/Tools/blocFissure/gmu/__init__.py @@ -17,6 +17,7 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""init de la classe""" import os from . import initLog diff --git a/src/Tools/blocFissure/gmu/ajustePointsEdgePipeFissure.py b/src/Tools/blocFissure/gmu/ajustePointsEdgePipeFissure.py index fe2df5839..41f23452d 100644 --- a/src/Tools/blocFissure/gmu/ajustePointsEdgePipeFissure.py +++ b/src/Tools/blocFissure/gmu/ajustePointsEdgePipeFissure.py @@ -17,6 +17,7 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Ajustement precis des points sur edgesPipeFissureExterneC""" import logging @@ -25,13 +26,11 @@ from .findWireIntermediateVertices import findWireIntermediateVertices from .projettePointSurCourbe import projettePointSurCourbe def ajustePointsEdgePipeFissure(edgesPipeFissureExterneC, wirePipeFissureExterne, gptsdisks, idisklim): - """ - ajustement precis des points sur edgesPipeFissureExterneC - """ + """Ajustement precis des points sur edgesPipeFissureExterneC""" logging.info('start') - + edgesPFE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False) - verticesPFE = findWireIntermediateVertices(wirePipeFissureExterne) # vertices intermédiaires (des points en trop dans ptsInWireFissExtPipe) + verticesPFE, _ = findWireIntermediateVertices(wirePipeFissureExterne) # vertices intermédiaires (des points en trop dans ptsInWireFissExtPipe) idiskmin = idisklim[0] + 1 # on ne prend pas le disque sur la peau, déjà ajusté idiskmax = idisklim[1] # on ne prend pas le disque sur la peau, déjà ajusté idiskint = [] @@ -39,8 +38,8 @@ def ajustePointsEdgePipeFissure(edgesPipeFissureExterneC, wirePipeFissureExterne distPtVt = [] for idisk in range(idiskmin, idiskmax): gptdsk = gptsdisks[idisk] - pt = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe - distPtVt.append((geompy.MinDistance(pt, vtx), idisk)) + point = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe + distPtVt.append((geompy.MinDistance(point, vtx), idisk)) distPtVt.sort() idiskint.append(distPtVt[0][1]) gptsdisks[idiskint[-1]][0][-1] = vtx @@ -50,12 +49,12 @@ def ajustePointsEdgePipeFissure(edgesPipeFissureExterneC, wirePipeFissureExterne break logging.debug("ajustement point sur edgePipeFissureExterne: %s", idisk) gptdsk = gptsdisks[idisk] - pt = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe - distPtEd = [(geompy.MinDistance(pt, edgePFE), k, edgePFE) for k, edgePFE in enumerate(edgesPFE)] + point = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe + distPtEd = [(geompy.MinDistance(point, edgePFE), k, edgePFE) for k, edgePFE in enumerate(edgesPFE)] distPtEd.sort() edgePFE = distPtEd[0][2] - u = projettePointSurCourbe(pt, edgePFE) - ptproj = geompy.MakeVertexOnCurve(edgePFE, u) + point_bis = projettePointSurCourbe(point, edgePFE) + ptproj = geompy.MakeVertexOnCurve(edgePFE, point_bis) gptsdisks[idisk][0][-1] = ptproj - return gptsdisks \ No newline at end of file + return gptsdisks diff --git a/src/Tools/blocFissure/gmu/blocDefaut.py b/src/Tools/blocFissure/gmu/blocDefaut.py index b28c714bd..9161d89f0 100644 --- a/src/Tools/blocFissure/gmu/blocDefaut.py +++ b/src/Tools/blocFissure/gmu/blocDefaut.py @@ -17,22 +17,20 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""bloc defaut""" import logging from .geomsmesh import geompy -# ----------------------------------------------------------------------------- -# --- bloc defaut - def blocDefaut(blocDim): - """ - Le bloc contenant la fissure est un cube construit centre a l'origine, dont on donne la demi arete. + """ Le bloc contenant la fissure est un cube construit centre a l'origine, dont on donne la demi arete. + @param blocdim : demi arete @return cube (geomObject) """ logging.info("start") - geomObj_1 = geompy.MakeVertex(-blocDim, -blocDim, -blocDim) - geomObj_2 = geompy.MakeVertex( blocDim, blocDim, blocDim) - Box = geompy.MakeBoxTwoPnt(geomObj_1, geomObj_2) - #geompy.addToStudy( Box_1, 'Box_1' ) - return Box + point_1 = geompy.MakeVertex(-blocDim, -blocDim, -blocDim) + point_2 = geompy.MakeVertex( blocDim, blocDim, blocDim) + le_cube = geompy.MakeBoxTwoPnt(point_1, point_2) + + return le_cube diff --git a/src/Tools/blocFissure/gmu/calculePointsAxiauxPipe.py b/src/Tools/blocFissure/gmu/calculePointsAxiauxPipe.py index 466007a5f..79e3215a7 100644 --- a/src/Tools/blocFissure/gmu/calculePointsAxiauxPipe.py +++ b/src/Tools/blocFissure/gmu/calculePointsAxiauxPipe.py @@ -17,6 +17,7 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Préparation maillage du pipe""" import logging import math @@ -27,7 +28,7 @@ from .geomsmesh import smesh def calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut, centreFondFiss, wireFondFiss, wirePipeFiss, lenSegPipe, rayonPipe, nbsegCercle, nbsegRad): - """preparation maillage du pipe : + """Préparation maillage du pipe : - détections des points a respecter : jonction des edges/faces constituant la face de fissure externe au pipe @@ -59,7 +60,7 @@ def calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut, meshFondExt = smesh.Mesh(wireFondFiss) algo1d = meshFondExt.Segment() - hypo1d = algo1d.Adaptive(lgmin, lgmax, deflexion) # a ajuster selon la profondeur de la fissure + _ = algo1d.Adaptive(lgmin, lgmax, deflexion) # a ajuster selon la profondeur de la fissure is_done = meshFondExt.Compute() text = "calculePointsAxiauxPipe meshFondExt.Compute" @@ -75,11 +76,11 @@ def calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut, for nodeId in allNodeIds: xyz = meshFondExt.GetNodeXYZ(nodeId) #logging.debug("nodeId %s, coords %s", nodeId, str(xyz)) - pt = geompy.MakeVertex(xyz[0], xyz[1], xyz[2]) - u, PointOnEdge, EdgeInWireIndex = geompy.MakeProjectionOnWire(pt, wireFondFiss) # u compris entre 0 et 1 + point = geompy.MakeVertex(xyz[0], xyz[1], xyz[2]) + parametre, _, EdgeInWireIndex = geompy.MakeProjectionOnWire(point, wireFondFiss) # parametre compris entre 0 et 1 edgeOrder = edgesIdByOrientation[EdgeInWireIndex] - ptGSdic[(edgeOrder, EdgeInWireIndex, u)] = pt - #logging.debug("nodeId %s, u %s", nodeId, str(u)) + ptGSdic[(edgeOrder, EdgeInWireIndex, parametre)] = point + #logging.debug("nodeId %s, parametre %s", nodeId, str(parametre)) usort = sorted(ptGSdic) logging.debug("nombre de points obtenus par deflexion %s",len(usort)) @@ -88,10 +89,10 @@ def calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut, normals = list() for edu in usort: ied = edu[1] - u = edu[2] + parametre = edu[2] vertcx = ptGSdic[edu] - norm = geompy.MakeTangentOnCurve(edgesFondFiss[ied], u) - plan = geompy.MakePlane(vertcx, norm, 3*rayonPipe) + norm = geompy.MakeTangentOnCurve(edgesFondFiss[ied], parametre) + plan = geompy.MakePlane(vertcx, norm, 3.*rayonPipe) part = geompy.MakePartition([plan], [wirePipeFiss], list(), list(), geompy.ShapeType["VERTEX"], 0, list(), 0) liste = geompy.ExtractShapes(part, geompy.ShapeType["VERTEX"], True) if len(liste) == 5: # 4 coins du plan plus intersection recherchée @@ -117,29 +118,31 @@ def calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut, # --- points géométriques gptsdisks = list() # vertices géométrie de tous les disques - raydisks = [list() for i in range(nbsegCercle)] - for i, centres_i in enumerate(centres): # boucle sur les disques + raydisks = [list() for _ in range(nbsegCercle)] + for indice, centres_i in enumerate(centres): # boucle sur les disques gptdsk = list() # vertices géométrie d'un disque vertcx = centres_i - vertpx = origins[i] - normal = normals[i] + vertpx = origins[indice] + normal = normals[indice] vec1 = geompy.MakeVector(vertcx, vertpx) points = [vertcx] # les points du rayon de référence + dist_0 = rayonPipe/float(nbsegRad) for j in range(nbsegRad): - pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, (j+1)*float(rayonPipe)/nbsegRad) - points.append(pt) + point = geompy.MakeTranslationVectorDistance(vertcx, vec1, (j+1)*dist_0) + points.append(point) gptdsk.append(points) - pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, 1.5*rayonPipe) - rayon = geompy.MakeLineTwoPnt(vertcx, pt) + point = geompy.MakeTranslationVectorDistance(vertcx, vec1, 1.5*rayonPipe) + rayon = geompy.MakeLineTwoPnt(vertcx, point) raydisks[0].append(rayon) + angle_0 = 2.*math.pi/float(nbsegCercle) for k in range(nbsegCercle-1): - angle = (k+1)*2*math.pi/nbsegCercle + angle = float(k+1)*angle_0 pts = [vertcx] # les points d'un rayon obtenu par rotation for j in range(nbsegRad): - pt = geompy.MakeRotation(points[j+1], normal, angle) - pts.append(pt) + point = geompy.MakeRotation(points[j+1], normal, angle) + pts.append(point) gptdsk.append(pts) ray = geompy.MakeRotation(rayon, normal, angle) raydisks[k+1].append(ray) diff --git a/src/Tools/blocFissure/gmu/casStandard.py b/src/Tools/blocFissure/gmu/casStandard.py index 6e1ed81a4..ecce71672 100644 --- a/src/Tools/blocFissure/gmu/casStandard.py +++ b/src/Tools/blocFissure/gmu/casStandard.py @@ -20,16 +20,17 @@ """Cas standard""" import os -from .geomsmesh import geompy, smesh -from .geomsmesh import geomPublish -from .geomsmesh import geomPublishInFather -from . import initLog +import logging -import math import GEOM import SALOMEDS import SMESH -import logging + +from .geomsmesh import geompy, smesh +from .geomsmesh import geomPublish +from .geomsmesh import geomPublishInFather + +from . import initLog from .fissureGenerique import fissureGenerique @@ -88,7 +89,7 @@ class casStandard(fissureGenerique): def genereMaillageSain(self, geometriesSaines, meshParams): logging.info("genereMaillageSain %s", self.nomCas) - ([objetSain], status) = smesh.CreateMeshesFromMED(self.dicoParams['maillageSain']) + ([objetSain], _) = smesh.CreateMeshesFromMED(self.dicoParams['maillageSain']) smesh.SetName(objetSain.GetMesh(), 'objetSain') return [objetSain, True] # True : maillage hexa diff --git a/src/Tools/blocFissure/gmu/checkDecoupePartition.py b/src/Tools/blocFissure/gmu/checkDecoupePartition.py index 7b9ffad64..4eecc5fd6 100644 --- a/src/Tools/blocFissure/gmu/checkDecoupePartition.py +++ b/src/Tools/blocFissure/gmu/checkDecoupePartition.py @@ -17,17 +17,15 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Teste si l'opération de partition a produit une modification""" import logging from .geomsmesh import geompy -# ----------------------------------------------------------------------------- -# --- teste si l'opération de partition a produit une modification def checkDecoupePartition(shapes, part): - """ - Teste si l'opération de partition a produit une découpe - (plus de shapes dans la partition). + """Teste si l'opération de partition a produit une découpe (plus de shapes dans la partition). + Résultat non garanti si recouvrement des shapes d'origine. @param shapes : liste des shapes d'origine @param part : résultat de la partition @@ -35,25 +33,25 @@ def checkDecoupePartition(shapes, part): """ logging.info('start') # TODO: ShapeInfo donne des résultats faux (deux faces au lieu de une) - - isPart = False - orig = {} + + orig = dict() for shape in shapes: info = geompy.ShapeInfo(shape) logging.debug("shape info %s", info) - for k in ['VERTEX', 'EDGE', 'FACE', 'SOLID']: - if k in list(orig.keys()): - orig[k] += info[k] + for type_shape in ['VERTEX', 'EDGE', 'FACE', 'SOLID']: + if type_shape in orig: + orig[type_shape] += info[type_shape] else: - orig[k] = info[k] + orig[type_shape] = info[type_shape] logging.debug("original shapes info %s", orig) + info = geompy.ShapeInfo(part) logging.debug("partition info %s", info) - for k in ['VERTEX', 'EDGE', 'FACE', 'SOLID']: - if orig[k] < info[k]: - isPart = True + decoupe = False + for type_shape in ['VERTEX', 'EDGE', 'FACE', 'SOLID']: + if orig[type_shape] < info[type_shape]: + decoupe = True break - logging.debug("partition modifie l'original %s", isPart) - - return isPart + logging.debug("partition modifie l'original %s", decoupe) + return decoupe diff --git a/src/Tools/blocFissure/gmu/commonSubShapes.py b/src/Tools/blocFissure/gmu/commonSubShapes.py index 91d94b003..c0102fa39 100644 --- a/src/Tools/blocFissure/gmu/commonSubShapes.py +++ b/src/Tools/blocFissure/gmu/commonSubShapes.py @@ -17,25 +17,25 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""subShapes communes à deux listes""" import logging from .geomsmesh import geompy -# ----------------------------------------------------------------------------- -# --- subShapes communes à deux listes - def commonSubShapes(obj, sub1, sub2): - """ - liste de subshapes communes - """ + """liste de subshapes communes""" logging.info("start") - idsub1 = {} - subList = [] - for s in sub1: - idsub1[geompy.GetSubShapeID(obj, s)] = s - for s in sub2: - idsub = geompy.GetSubShapeID(obj, s) - if idsub in list(idsub1.keys()): - subList.append(s) - logging.debug("subList=%s", subList) - return subList + + idsub1 = dict() + for subshape in sub1: + idsub1[geompy.GetSubShapeID(obj, subshape)] = subshape + + l_subshapes = list() + for subshape in sub2: + idsub = geompy.GetSubShapeID(obj, subshape) + if idsub in idsub1: + l_subshapes.append(subshape) + + logging.debug("l_subshapes=%s", l_subshapes) + + return l_subshapes diff --git a/src/Tools/blocFissure/gmu/compoundFromList.py b/src/Tools/blocFissure/gmu/compoundFromList.py index 781ee2c46..5c866915c 100644 --- a/src/Tools/blocFissure/gmu/compoundFromList.py +++ b/src/Tools/blocFissure/gmu/compoundFromList.py @@ -17,36 +17,36 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""compoundFromList""" import logging from .geomsmesh import geompy from .geomsmesh import geomPublish -from .geomsmesh import geomPublishInFather from . import initLog def compoundFromList(elements, nom=None): """compoundFromList""" logging.debug('start') - - shapeList = list() - for a in elements: - if not isinstance(a, list): - shapeList.append(a) + + l_shapes = list() + for elem in elements: + if not isinstance(elem, list): + l_shapes.append(elem) else: - if a[0] is not None: - shapeList.append(a[0]) - + if elem[0] is not None: + l_shapes.append(elem[0]) + if nom is not None: - for i,a in enumerate(shapeList): - nomi = nom +"%d"%i + for indice, elem in enumerate(l_shapes): + nomi = nom +"%d"%indice logging.debug('nom: %s',nomi) - geomPublish(initLog.debug, a, nomi) + geomPublish(initLog.debug, elem, nomi) shapeCompound = None - if len(shapeList) > 0: - shapeCompound =geompy.MakeCompound(shapeList) + if l_shapes: + shapeCompound = geompy.MakeCompound(l_shapes) nomc = "compound_%s"%nom geomPublish(initLog.debug, shapeCompound, nomc) + return shapeCompound - diff --git a/src/Tools/blocFissure/gmu/construitFissureGenerale.py b/src/Tools/blocFissure/gmu/construitFissureGenerale.py index feed23ef9..7500a5440 100644 --- a/src/Tools/blocFissure/gmu/construitFissureGenerale.py +++ b/src/Tools/blocFissure/gmu/construitFissureGenerale.py @@ -20,14 +20,17 @@ """procédure complète de construction d'une fissure générale""" import logging + +from . import initLog + import salome +from salome.smesh import smeshBuilder +import GEOM +import SMESH + from .geomsmesh import geompy from .geomsmesh import geomPublishInFather -from . import initLog -import GEOM from .geomsmesh import smesh -from salome.smesh import smeshBuilder -import SMESH from .orderEdgesFromWire import orderEdgesFromWire from .restreintFaceFissure import restreintFaceFissure diff --git a/src/Tools/blocFissure/gmu/construitFissureGenerale_c.py b/src/Tools/blocFissure/gmu/construitFissureGenerale_c.py index cb631d093..767862f81 100644 --- a/src/Tools/blocFissure/gmu/construitFissureGenerale_c.py +++ b/src/Tools/blocFissure/gmu/construitFissureGenerale_c.py @@ -22,13 +22,15 @@ import os import logging + import salome -from .geomsmesh import geompy -import GEOM -from .geomsmesh import smesh from salome.smesh import smeshBuilder +import GEOM import SMESH +from .geomsmesh import geompy +from .geomsmesh import smesh + from .putName import putName from .enleveDefaut import enleveDefaut from .shapeSurFissure import shapeSurFissure diff --git a/src/Tools/blocFissure/gmu/construitPartitionsPeauFissure.py b/src/Tools/blocFissure/gmu/construitPartitionsPeauFissure.py index 76fba5409..31a3b079f 100644 --- a/src/Tools/blocFissure/gmu/construitPartitionsPeauFissure.py +++ b/src/Tools/blocFissure/gmu/construitPartitionsPeauFissure.py @@ -17,21 +17,23 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""peau et face de fissure + +partition peau défaut - face de fissure prolongée - wire de fond de fissure prolongée +il peut y avoir plusieurs faces externes, dont certaines sont découpées par la fissure +liste de faces externes : facesDefaut +liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection) +""" import logging + +from . import initLog + from .geomsmesh import geompy from .geomsmesh import geomPublish from .geomsmesh import geomPublishInFather -from . import initLog -from .checkDecoupePartition import checkDecoupePartition - # ----------------------------------------------------------------------------- - # --- peau et face de fissure - # - # --- partition peau défaut - face de fissure prolongée - wire de fond de fissure prolongée - # il peut y avoir plusieurs faces externes, dont certaines sont découpées par la fissure - # liste de faces externes : facesDefaut - # liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection) +from .checkDecoupePartition import checkDecoupePartition def construitPartitionsPeauFissure(facesDefaut, fissPipe): """partition peau défaut - face de fissure prolongée - wire de fond de fissure prolongée. @@ -47,8 +49,8 @@ def construitPartitionsPeauFissure(facesDefaut, fissPipe): ipart = 0 for filling in facesDefaut: part = geompy.MakePartition([fissPipe, filling], list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 0) - isPart = checkDecoupePartition([fissPipe, filling], part) - if isPart: # on recrée la partition avec toutes les faces filling en outil pour avoir une face de fissure correcte + # on recrée la partition avec toutes les faces filling en outil pour avoir une face de fissure correcte + if checkDecoupePartition([fissPipe, filling], part): otherFD = [fd for fd in facesDefaut if fd != filling] if otherFD: fissPipePart = geompy.MakePartition([fissPipe], otherFD, list(), list(), geompy.ShapeType["FACE"], 0, list(), 0) diff --git a/src/Tools/blocFissure/gmu/creePointsPipePeau.py b/src/Tools/blocFissure/gmu/creePointsPipePeau.py index 9daf6ac04..e13105eb7 100644 --- a/src/Tools/blocFissure/gmu/creePointsPipePeau.py +++ b/src/Tools/blocFissure/gmu/creePointsPipePeau.py @@ -17,35 +17,34 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""création des points du maillage du pipe sur la face de peau""" import logging +from . import initLog from .geomsmesh import geompy from .geomsmesh import geomPublish from .geomsmesh import geomPublishInFather -from . import initLog from .projettePointSurCourbe import projettePointSurCourbe def creePointsPipePeau(listEdges, idFacesDebouchantes, idFillingFromBout, ptEdgeFond, ptFisExtPi, edCircPeau, gptsdisks, idisklim, nbsegRad): - """ - création des points du maillage du pipe sur la face de peau - """ + """création des points du maillage du pipe sur la face de peau""" logging.info('start') - - for i, edges in enumerate(listEdges): - idf = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau) + + for n_edges, edges in enumerate(listEdges): + idf = idFacesDebouchantes[n_edges] # indice de face débouchante (facesPipePeau) if idf >= 0: - gptdsk = [] + gptdsk = list() if idf > 0: # idf vaut 0 ou 1 idf = -1 # si idf vaut 1, on prend le dernier élément de la liste (1 ou 2 extrémités débouchent sur la face) - centre = ptEdgeFond[idFillingFromBout[i]][idf] + centre = ptEdgeFond[idFillingFromBout[n_edges]][idf] name = "centre%d"%idf geomPublish(initLog.debug, centre, name) - vertPipePeau = ptFisExtPi[idFillingFromBout[i]][idf] + vertPipePeau = ptFisExtPi[idFillingFromBout[n_edges]][idf] geomPublishInFather(initLog.debug, centre, vertPipePeau, "vertPipePeau") - grpsEdgesCirc = edCircPeau[idFillingFromBout[i]] # liste de groupes - edgesCirc = [] + grpsEdgesCirc = edCircPeau[idFillingFromBout[n_edges]] # liste de groupes + edgesCirc = list() for grpEdgesCirc in grpsEdgesCirc: edgesCirc += geompy.ExtractShapes(grpEdgesCirc, geompy.ShapeType["EDGE"], False) for k, edge in enumerate(edges): @@ -59,32 +58,31 @@ def creePointsPipePeau(listEdges, idFacesDebouchantes, idFillingFromBout, distEdgeCirc = [(geompy.MinDistance(bout, edgeCirc), k2, edgeCirc) for k2, edgeCirc in enumerate(edgesCirc)] distEdgeCirc.sort() logging.debug("distEdgeCirc: %s", distEdgeCirc) - u = projettePointSurCourbe(bout, distEdgeCirc[0][2]) - if (abs(u) < 0.02) or (abs(1-u) < 0.02): # les points très proches d'une extrémité doivent y être mis précisément. + dist = projettePointSurCourbe(bout, distEdgeCirc[0][2]) + if (abs(dist) < 0.02) or (abs(1.-dist) < 0.02): # les points très proches d'une extrémité doivent y être mis précisément. extrCircs = geompy.ExtractShapes(distEdgeCirc[0][2], geompy.ShapeType["VERTEX"], True) if geompy.MinDistance(bout, extrCircs[0]) < geompy.MinDistance(bout, extrCircs[1]): bout = extrCircs[0] else: bout = extrCircs[1] else: - bout = geompy.MakeVertexOnCurve(distEdgeCirc[0][2], u) + bout = geompy.MakeVertexOnCurve(distEdgeCirc[0][2], dist) name ="bout%d"%k geomPublishInFather(initLog.debug, centre, bout, name) # enregistrement des points dans la structure - points = [] - for j in range(nbsegRad +1): - u = j/float(nbsegRad) - points.append(geompy.MakeVertexOnCurve(edge, u)) + points = list() + for n_seg in range(nbsegRad +1): + points.append(geompy.MakeVertexOnCurve(edge, float(n_seg)/float(nbsegRad))) if geompy.MinDistance(bout, points[0]) < geompy.MinDistance(centre, points[0]): points.reverse() points[0] = centre points[-1] = bout gptdsk.append(points) - if i == 0: + if n_edges == 0: gptsdisks[idisklim[0] -1] = gptdsk idisklim[0] = idisklim[0] -1 else: gptsdisks[idisklim[1] +1] = gptdsk idisklim[1] = idisklim[1] +1 - - return (gptsdisks, idisklim) \ No newline at end of file + + return (gptsdisks, idisklim) diff --git a/src/Tools/blocFissure/gmu/creeZoneDefautDansObjetSain.py b/src/Tools/blocFissure/gmu/creeZoneDefautDansObjetSain.py index ed7df4701..d14f26ee2 100644 --- a/src/Tools/blocFissure/gmu/creeZoneDefautDansObjetSain.py +++ b/src/Tools/blocFissure/gmu/creeZoneDefautDansObjetSain.py @@ -17,14 +17,16 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""TODO: a compléter""" import os import logging -from .geomsmesh import smesh import SMESH import SALOMEDS +from .geomsmesh import smesh + from .creeZoneDefautMaillage import creeZoneDefautMaillage from .peauInterne import peauInterne from .quadranglesToShapeNoCorner import quadranglesToShapeNoCorner @@ -32,10 +34,7 @@ from .creeZoneDefautFilling import creeZoneDefautFilling from .creeZoneDefautGeom import creeZoneDefautGeom from .getCentreFondFiss import getCentreFondFiss -# ----------------------------------------------------------------------------- -# --- - -def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, +def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, \ shapeFissureParams, maillageFissureParams): """ #TODO: a compléter @@ -65,11 +64,10 @@ def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, nomFicSain = maillageFissureParams['nomFicSain'] fichierMaillageSain = os.path.join (nomRep , '{}.med'.format(nomFicSain)) - + # --- centre de fond de fissure et tangente - + edgeFondExt, centreFondFiss, tgtCentre = getCentreFondFiss(shapesFissure) - # --- zone de défaut nomZones = "zoneDefaut" @@ -89,9 +87,9 @@ def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, isPlane = False if isHexa and not isPlane: meshQuad = smesh.CopyMesh( zoneDefaut_skin, 'meshQuad', 0, 0) - - fillings, noeuds_bords, bordsPartages, fillconts, idFilToCont = quadranglesToShapeNoCorner(meshQuad, shapeFissureParams, centreFondFiss) - + + fillings, _, bordsPartages, fillconts, idFilToCont = quadranglesToShapeNoCorner(meshQuad, shapeFissureParams, centreFondFiss) + for filling in fillings: [faceDefaut, centreDefaut, normalDefaut, extrusionDefaut] = \ creeZoneDefautFilling(filling, shapeDefaut, lgExtrusion) @@ -101,14 +99,15 @@ def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, extrusionsDefaut.append(extrusionDefaut) else: [facesDefaut, centreDefaut, normalDefaut, extrusionDefaut] = \ - creeZoneDefautGeom( geometrieSaine, shapeDefaut, origShapes, verticesShapes, dmoyen, lgExtrusion) + creeZoneDefautGeom( geometrieSaine, shapeDefaut, origShapes, verticesShapes, lgExtrusion) bordsPartages = list() - for face in facesDefaut: + for _ in facesDefaut: bordsPartages.append([None,None]) # TODO : traitement des arêtes vives ? fillconts = facesDefaut idFilToCont = list(range(len(facesDefaut))) - return [facesDefaut, centresDefaut, normalsDefaut, extrusionsDefaut, dmoyen, bordsPartages, fillconts, idFilToCont, - maillageSain, internalBoundary, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges, + return [facesDefaut, centresDefaut, normalsDefaut, extrusionsDefaut, \ + dmoyen, bordsPartages, fillconts, idFilToCont, \ + maillageSain, internalBoundary, \ + zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges, \ edgeFondExt, centreFondFiss, tgtCentre] - diff --git a/src/Tools/blocFissure/gmu/creeZoneDefautFilling.py b/src/Tools/blocFissure/gmu/creeZoneDefautFilling.py index 6835a003f..b925b95fc 100644 --- a/src/Tools/blocFissure/gmu/creeZoneDefautFilling.py +++ b/src/Tools/blocFissure/gmu/creeZoneDefautFilling.py @@ -17,20 +17,20 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Crée zone géométrique défaut a partir d'un filling""" import logging + +from . import initLog + from .geomsmesh import geompy from .geomsmesh import geomPublish from .geomsmesh import geomPublishInFather -from . import initLog - -# ----------------------------------------------------------------------------- -# --- crée zone géométrique défaut a partir d'un filling def creeZoneDefautFilling(filling, shapeDefaut, lgExtrusion=50): - """ - Construction CAO de la zone à remailler, quand on utilise un filling, + """Construction CAO de la zone à remailler, quand on utilise un filling, après appel creeZoneDefautMaillage et quadranglesToShapeNoCorner + @param filling : la CAO de la peau du défaut reconstituée @param shapeDefaut : objet géométrique représentant la fissure (selon les cas, un point central, ou une shape plus complexe, diff --git a/src/Tools/blocFissure/gmu/creeZoneDefautGeom.py b/src/Tools/blocFissure/gmu/creeZoneDefautGeom.py index 8d01a40ff..3232beb15 100644 --- a/src/Tools/blocFissure/gmu/creeZoneDefautGeom.py +++ b/src/Tools/blocFissure/gmu/creeZoneDefautGeom.py @@ -20,23 +20,21 @@ """Zone de défaut, constructions géométrique avec CAO d'origine""" import logging +from . import initLog + from .geomsmesh import geompy from .geomsmesh import geomPublish -from .geomsmesh import geomPublishInFather -from . import initLog from .prolongeVertices import prolongeVertices -def creeZoneDefautGeom(objetSain, shapeDefaut, origShapes, verticesShapes, dmoyen, lgExtrusion=50): - """ - Construction CAO de la zone à remailler, quand on utilise la CAO d'origine, - apres appel creeZoneDefautMaillage +def creeZoneDefautGeom(objetSain, shapeDefaut, origShapes, verticesShapes, lgExtrusion=50): + """Construction CAO de la zone à remailler, quand on utilise la CAO d'origine,apres appel creeZoneDefautMaillage + @param objetSain : la géometrie de l'objet initial @param shapeDefaut : objet géometrique représentant la fissure (selon les cas, un point central, ou une shape plus complexe, dont on ne garde que les vertices) @param origShapes : liste id subShapes @param verticesShapes : listes noeuds de bord - @param dmoyen : longueur arete moyenne bord @lgExtrusion : distance d'extrusion de la face du defaut (ne vaut que pour des fissures courtes) @return (facesDefaut, centreDefaut, normalDefaut, extrusionDefaut) @@ -182,9 +180,8 @@ def creeZoneDefautGeom(objetSain, shapeDefaut, origShapes, verticesShapes, dmoye minDist = min(distances) for indice, dist in enumerate(distances): if dist == minDist: - indice0 = indice + theShellDefaut = shells[indice] break - theShellDefaut = shells[indice0] # else: # --- une seule face de defaut subFaces = [facesDefaut] diff --git a/src/Tools/blocFissure/gmu/creeZoneDefautMaillage.py b/src/Tools/blocFissure/gmu/creeZoneDefautMaillage.py index 656b5ffe6..fcef65432 100644 --- a/src/Tools/blocFissure/gmu/creeZoneDefautMaillage.py +++ b/src/Tools/blocFissure/gmu/creeZoneDefautMaillage.py @@ -17,16 +17,17 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Zone de defaut extraite du maillage""" import logging -from .geomsmesh import geompy import math -from .distance2 import distance2 import traceback + +from .geomsmesh import geompy +from .distance2 import distance2 from .fissError import fissError # ----------------------------------------------------------------------------- -# --- zone de defaut extraite du maillage def creeZoneDefautMaillage(maillagesSains, shapeDefaut, tailleDefaut, nomZones, coordsNoeudsFissure): @@ -45,12 +46,13 @@ def creeZoneDefautMaillage(maillagesSains, shapeDefaut, tailleDefaut, @return (origShapes, verticesShapes, dmoyen) liste id subShapes, listes noeuds de bord, longueur arête moyenne bord """ logging.info("start") - logging.debug("distance d'influence (tailleDefaut) = %f" % tailleDefaut) + texte = "distance d'influence (tailleDefaut) = {}".format(tailleDefaut) + logging.debug(texte) #print (" shapeDefaut : {}".format(shapeDefaut)) #print (" nomZones : {}".format(nomZones)) maillageSain = maillagesSains[0] - isHexa = maillagesSains[1] + #isHexa = maillagesSains[1] lists = maillageSain.CreateHoleSkin(tailleDefaut, shapeDefaut, nomZones, coordsNoeudsFissure) #print("lists = {}".format(lists)) @@ -59,8 +61,8 @@ def creeZoneDefautMaillage(maillagesSains, shapeDefaut, tailleDefaut, origShapes = list() verticesShapes = list() - cumul = 0. # somme des distances carrées entre point ordonnés (taille des arêtes) - nb = 0 # nombre d'arêtes évaluées + cumul = 0. # somme des distances carrées entre points ordonnés (taille des arêtes) + nbar = 0 # nombre d'arêtes évaluées for aList in lists: aShape = aList[0] @@ -77,17 +79,18 @@ def creeZoneDefautMaillage(maillagesSains, shapeDefaut, tailleDefaut, xyz0 = xyz #logging.debug(" node %s %s", node, xyz) vertices.append(geompy.MakeVertex(xyz[0], xyz[1], xyz[2])) - nb += len(aList) - 2 + nbar += len(aList) - 2 verticesShapes.append(vertices) - #print ("nb = {}".format(nb)) + #print ("nbar = {}".format(nbar)) #print ("cumul = {}".format(cumul)) - if (nb == 0): + if (nbar == 0): texte = "La zone à remailler n'est pas détectée correctement.
" texte += "Cause possible :" raise fissError(traceback.extract_stack(),texte) - dmoyen = math.sqrt(cumul/float(nb)) # ~ taille de l'arête moyenne du maillage global + dmoyen = math.sqrt(cumul/float(nbar)) # ~ taille de l'arête moyenne du maillage global + return origShapes, verticesShapes, dmoyen diff --git a/src/Tools/blocFissure/gmu/distance2.py b/src/Tools/blocFissure/gmu/distance2.py index 17e41fe78..22da3526d 100644 --- a/src/Tools/blocFissure/gmu/distance2.py +++ b/src/Tools/blocFissure/gmu/distance2.py @@ -17,38 +17,40 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""calcul du carré de la distance entre deux points""" import logging # ----------------------------------------------------------------------------- -# --- calcul de distance carree entre deux points, jeux de coordonnees x,y,z +# --- def distance2(xyz1, xyz2): """ carré de la distance entre deux points donnés par des triplets [x,y,z] """ #logging.info("start") - - d2 = 0 - for i in range(3): - d2 += (xyz1[i]-xyz2[i])*(xyz1[i]-xyz2[i]) - logging.debug('d2=%s', d2) - return d2 -# ----------------------------------------------------------------------------- -# --- test unitaire - -import unittest -class Test_distance2(unittest.TestCase): - - def setUp(self): - self.a=[0, 0, 0] - self.b=[3, 4, 5] - self.c=[-5,-4,-3] - - def test_calcul(self): - self.assertEqual(distance2(self.a, self.b), distance2(self.b, self.a)) - self.assertEqual(distance2(self.a, self.b), distance2(self.a, self.c)) - self.assertEqual(distance2(self.b, self.b), 0) - self.assertEqual(distance2(self.a, self.b), 50) - \ No newline at end of file + dcarre = 0 + for ijk in range(3): + dcarre += (xyz1[ijk]-xyz2[ijk])*(xyz1[ijk]-xyz2[ijk]) + logging.debug('dcarre=%s', dcarre) + + return dcarre + +## ----------------------------------------------------------------------------- +## --- test unitaire + +#import unittest +#class Test_distance2(unittest.TestCase): + #"""test de la fonction""" + + #def setUp(self): + #self.a=[0, 0, 0] + #self.b=[3, 4, 5] + #self.c=[-5,-4,-3] + + #def test_calcul(self): + #self.assertEqual(distance2(self.a, self.b), distance2(self.b, self.a)) + #self.assertEqual(distance2(self.a, self.b), distance2(self.a, self.c)) + #self.assertEqual(distance2(self.b, self.b), 0) + #self.assertEqual(distance2(self.a, self.b), 50) diff --git a/src/Tools/blocFissure/gmu/eliminateDoubles.py b/src/Tools/blocFissure/gmu/eliminateDoubles.py index 671d7d1f7..f037a790e 100644 --- a/src/Tools/blocFissure/gmu/eliminateDoubles.py +++ b/src/Tools/blocFissure/gmu/eliminateDoubles.py @@ -17,26 +17,28 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""éliminer les doublons d'une liste de subshapes""" import logging from .geomsmesh import geompy # ----------------------------------------------------------------------------- -# --- éliminer les doublons d'une liste de subshapes +# --- def eliminateDoubles(obj, subshapes): - """ - éliminer les doublons d'une liste de subshapes - """ - idsubs = {} + """éliminer les doublons d'une liste de subshapes""" + + idsubs = dict() for sub in subshapes: subid = geompy.GetSubShapeID(obj, sub) - if subid in list(idsubs.keys()): + if subid in idsubs: idsubs[subid].append(sub) else: idsubs[subid] = [sub] - shortList = [] - for k, v in idsubs.items(): - shortList.append(v[0]) + + shortList = list() + for l_sub in idsubs.items(): + shortList.append(l_sub[0]) logging.debug("shortList=%s", shortList) + return shortList diff --git a/src/Tools/blocFissure/gmu/elimineExtremitesPipe.py b/src/Tools/blocFissure/gmu/elimineExtremitesPipe.py index b584c0c91..369271980 100644 --- a/src/Tools/blocFissure/gmu/elimineExtremitesPipe.py +++ b/src/Tools/blocFissure/gmu/elimineExtremitesPipe.py @@ -17,6 +17,7 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Recherche des points en trop (externes au volume à remailler)""" import logging @@ -24,33 +25,34 @@ from .geomsmesh import geompy from .whichSideVertex import whichSideVertex def elimineExtremitesPipe(ptEdgeFond, facesDefaut, centres, gptsdisks, nbsegCercle): - """ - recherche des points en trop (externes au volume à remailler) - - on associe chaque extrémité du pipe à une face filling + """Recherche des points en trop (externes au volume à remailler) + + - on associe chaque extrémité du pipe à une face filling - on part des disques aux extrémités du pipe - pour chaque disque, on prend les vertices de géométrie, on marque leur position relative à la face. - on s'arrete quand tous les noeuds sont dedans """ - + logging.info('start') - pt0 = centres[0] - pt1 = centres[-1] + point_0 = centres[0] + point_1 = centres[-1] idFillingFromBout = [None, None] # contiendra l'index du filling pour les extrémités 0 et 1 nbFacesFilling = len(ptEdgeFond) for ifil in range(nbFacesFilling): - for ipt, pt in enumerate(ptEdgeFond[ifil]): # il y a un ou deux points débouchant sur cette face - if geompy.MinDistance(pt,pt0) < geompy.MinDistance(pt,pt1): # TODO: trouver plus fiable pour les cas tordus... + for point in ptEdgeFond[ifil]: # il y a un ou deux points débouchant sur cette face + if geompy.MinDistance(point,point_0) < geompy.MinDistance(point,point_1): # TODO: trouver plus fiable pour les cas tordus... idFillingFromBout[0] = ifil - else: + else: idFillingFromBout[1] = ifil logging.debug("association bouts du pipe - faces de filling: %s", idFillingFromBout) - + logging.debug("recherche des disques de noeuds complètement internes") - idisklim = [] # indices des premier et dernier disques internes - idiskout = [] # indices des premier et dernier disques externes + idisklim = list() # indices des premier et dernier disques internes + idiskout = list() # indices des premier et dernier disques externes for bout in range(2): + if bout == 0: idisk = -1 inc = 1 @@ -59,26 +61,28 @@ def elimineExtremitesPipe(ptEdgeFond, facesDefaut, centres, gptsdisks, nbsegCerc idisk = len(gptsdisks) inc = -1 numout = len(gptsdisks) + inside = False outside = True while not inside: - idisk = idisk + inc + idisk += inc logging.debug("examen disque %s", idisk) gptdsk = gptsdisks[idisk] inside = True - for k in range(nbsegCercle): - points = gptdsk[k] - for j, pt in enumerate(points): - side = whichSideVertex(facesDefaut[idFillingFromBout[bout]], pt) + for n_seg in range(nbsegCercle): + points = gptdsk[n_seg] + for point in points: + side = whichSideVertex(facesDefaut[idFillingFromBout[bout]], point) if side < 0: if outside: # premier point detecté dedans outside = False numout = idisk -inc # le disque précédent était dehors else: - inside = False # ce point est dehors + inside = False # ce point est dehors if not inside and not outside: break + idisklim.append(idisk) # premier et dernier disques internes idiskout.append(numout) # premier et dernier disques externes - - return (idFillingFromBout, idisklim, idiskout) \ No newline at end of file + + return (idFillingFromBout, idisklim, idiskout) diff --git a/src/Tools/blocFissure/gmu/ellipsoideDefaut.py b/src/Tools/blocFissure/gmu/ellipsoideDefaut.py index 6a3f50b06..8e2788dde 100644 --- a/src/Tools/blocFissure/gmu/ellipsoideDefaut.py +++ b/src/Tools/blocFissure/gmu/ellipsoideDefaut.py @@ -17,26 +17,25 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""ellipsoide defaut""" import logging import math + from .geomsmesh import geompy from .triedreBase import triedreBase -O, OX, OY, OZ = triedreBase() -# ----------------------------------------------------------------------------- -# --- ellipsoide defaut +O, OX, OY, OZ = triedreBase() -def ellipsoideDefaut(minRad,allonge,rayTore): - """ - Le bloc contenant la fissure est un ellipsoide construit centre a l'origine, +def ellipsoideDefaut(minRad,allonge): + """Le bloc contenant la fissure est un ellipsoide construit centre a l'origine, contenant le tore elliptique de fissure + @param minRad :petit rayon @param allonge :rapport grand rayon / petit rayon - @param rayTore :rayon du tore construit autour de la generatrice de l'ellipse @return ellipsoide (geomObject) """ - logging.info("start") + logging.info("start") boule = geompy.MakeSphereR(2) bouler = geompy.MakeRotation(boule, OY, math.pi/2.0) face = geompy.MakeFaceHW(100, 100, 3) diff --git a/src/Tools/blocFissure/gmu/enleveDefaut.py b/src/Tools/blocFissure/gmu/enleveDefaut.py index 13f184132..77d7c0e75 100644 --- a/src/Tools/blocFissure/gmu/enleveDefaut.py +++ b/src/Tools/blocFissure/gmu/enleveDefaut.py @@ -17,26 +17,29 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""maillage sain sans la zone de défaut""" import logging -# ----------------------------------------------------------------------------- -# --- maillage sain sans la zone defaut def enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges): - """ - Maillage sain sans la zone de defaut + """Maillage sain sans la zone de défaut + TODO: a completer """ logging.info('start') maillageSain.RemoveGroupWithContents(zoneDefaut) + if zoneDefaut_skin is not None: maillageSain.RemoveGroupWithContents(zoneDefaut_skin) + if zoneDefaut_internalFaces is not None: maillageSain.RemoveGroupWithContents(zoneDefaut_internalFaces) + if zoneDefaut_internalEdges is not None: maillageSain.RemoveGroupWithContents(zoneDefaut_internalEdges) - nbRemoved = maillageSain.RemoveOrphanNodes() - return maillageSain + _ = maillageSain.RemoveOrphanNodes() + + return maillageSain diff --git a/src/Tools/blocFissure/gmu/extractionOrientee.py b/src/Tools/blocFissure/gmu/extractionOrientee.py index 5396b4fcb..5b0bf17bb 100644 --- a/src/Tools/blocFissure/gmu/extractionOrientee.py +++ b/src/Tools/blocFissure/gmu/extractionOrientee.py @@ -17,17 +17,14 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Renvoie l'extraction des shapes d'un objet selon leur position par rapport à la face""" import logging + from .geomsmesh import geompy -from .geomsmesh import geomPublish -from .geomsmesh import geomPublishInFather -from . import initLog from .whichSide import whichSide - -# ----------------------------------------------------------------------------- -# --- renvoie l'extraction des shapes d'un objet selon leur position par rapport à la face. +from .extractionOrientee_a import extractionOrientee_a def extractionOrientee(face, obj, ref, shapeType, tol, prefix=""): """ @@ -37,36 +34,22 @@ def extractionOrientee(face, obj, ref, shapeType, tol, prefix=""): """ logging.info('start') trace = True - sideRef = whichSide(face, ref) - logging.debug("ref side %s", sideRef) - shapesInside = [] - shapesOutside = [] - shapesOnside = [] + side_ref = whichSide(face, ref) + logging.debug("ref side %s", side_ref) + shapesInside = list() + shapesOutside = list() + shapesOnside = list() shapes = geompy.ExtractShapes(obj, geompy.ShapeType[shapeType], False) - i=0 - j=0 - k=0 + + i_aux = 0 + j_aux = 0 + k_aux = 0 prefix = prefix + shapeType for shape in shapes: side = whichSide(face, shape, tol) - if side == sideRef: - shapesInside.append(shape) - if trace: - name = prefix + "_Inside%d"%i - geomPublishInFather(initLog.debug, obj, shape, name) - i+=1 - elif side == -sideRef: - shapesOutside.append(shape) - if trace: - name = prefix + "_Outside%d"%j - geomPublishInFather(initLog.debug, obj, shape, name) - j+=1 - elif side == 0: - shapesOnside.append(shape) - if trace: - name = prefix + "_Onside%d"%k - geomPublishInFather(initLog.debug, obj, shape, name) - k+=1 - logging.debug("--- shape was %s", name) - return [shapesInside, shapesOutside, shapesOnside] + i_aux, j_aux, k_aux = extractionOrientee_a(obj, shape, side, side_ref, \ + shapesInside, shapesOutside, shapesOnside, \ + i_aux, j_aux, k_aux, \ + trace, prefix) + return [shapesInside, shapesOutside, shapesOnside] diff --git a/src/Tools/blocFissure/gmu/extractionOrienteeMulti.py b/src/Tools/blocFissure/gmu/extractionOrienteeMulti.py index 2e9f68ea3..2c8dd308b 100644 --- a/src/Tools/blocFissure/gmu/extractionOrienteeMulti.py +++ b/src/Tools/blocFissure/gmu/extractionOrienteeMulti.py @@ -17,17 +17,14 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Renvoie l'extraction des shapes d'un objet selon leur position par rapport à la fac""" import logging + from .geomsmesh import geompy -from .geomsmesh import geomPublish -from .geomsmesh import geomPublishInFather -from . import initLog from .whichSideMulti import whichSideMulti - -# ----------------------------------------------------------------------------- -# --- renvoie l'extraction des shapes d'un objet selon leur position par rapport à la face. +from .extractionOrientee_a import extractionOrientee_a def extractionOrienteeMulti(faces, ifil, obj, centre, shapeType, tol, prefix=""): """ @@ -37,34 +34,20 @@ def extractionOrienteeMulti(faces, ifil, obj, centre, shapeType, tol, prefix="") """ logging.info('start') trace = True - shapesInside = [] - shapesOutside = [] - shapesOnside = [] + shapesInside = list() + shapesOutside = list() + shapesOnside = list() shapes = geompy.ExtractShapes(obj, geompy.ShapeType[shapeType], False) - i=0 - j=0 - k=0 + + i_aux = 0 + j_aux = 0 + k_aux = 0 prefix = prefix + shapeType for shape in shapes: side = whichSideMulti(faces, ifil, shape, centre, tol) - if side == 1: - shapesInside.append(shape) - if trace: - name = prefix + "_Inside%d"%i - geomPublishInFather(initLog.debug, obj, shape, name) - i+=1 - elif side == -1: - shapesOutside.append(shape) - if trace: - name = prefix + "_Outside%d"%j - geomPublishInFather(initLog.debug, obj, shape, name) - j+=1 - elif side == 0: - shapesOnside.append(shape) - if trace: - name = prefix + "_Onside%d"%k - geomPublishInFather(initLog.debug, obj, shape, name) - k+=1 - logging.debug("--- shape was %s", name) - return [shapesInside, shapesOutside, shapesOnside] + i_aux, j_aux, k_aux = extractionOrientee_a(obj, shape, side, 1, \ + shapesInside, shapesOutside, shapesOnside, \ + i_aux, j_aux, k_aux, \ + trace, prefix) + return [shapesInside, shapesOutside, shapesOnside] diff --git a/src/Tools/blocFissure/gmu/extractionOrientee_a.py b/src/Tools/blocFissure/gmu/extractionOrientee_a.py new file mode 100644 index 000000000..725c2219d --- /dev/null +++ b/src/Tools/blocFissure/gmu/extractionOrientee_a.py @@ -0,0 +1,57 @@ +# -*- coding: utf-8 -*- +# Copyright (C) 2014-2021 EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +"""Détermine le bon côté""" + +import logging +from . import initLog + +from .geomsmesh import geomPublishInFather + +def extractionOrientee_a(obj, shape, side, side_ref, \ + shapesInside, shapesOutside, shapesOnside, \ + i_aux, j_aux, k_aux, \ + trace=True, prefix=""): + """Détermine le bon côté""" + #logging.info('start') + + if side == side_ref: + shapesInside.append(shape) + if trace: + name = prefix + "_Inside%d"%i_aux + geomPublishInFather(initLog.debug, obj, shape, name) + i_aux += 1 + + elif side == -side_ref: + shapesOutside.append(shape) + if trace: + name = prefix + "_Outside%d"%j_aux + geomPublishInFather(initLog.debug, obj, shape, name) + j_aux += 1 + + elif side == 0: + shapesOnside.append(shape) + if trace: + name = prefix + "_Onside%d"%k_aux + geomPublishInFather(initLog.debug, obj, shape, name) + k_aux += 1 + + logging.debug("--- shape was %s", name) + + return i_aux, j_aux, k_aux diff --git a/src/Tools/blocFissure/gmu/facesCirculaires.py b/src/Tools/blocFissure/gmu/facesCirculaires.py index fbf6e3830..9af6c3c27 100644 --- a/src/Tools/blocFissure/gmu/facesCirculaires.py +++ b/src/Tools/blocFissure/gmu/facesCirculaires.py @@ -17,16 +17,14 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Tore : faces 1/2 circulaires et leur centre, edges de ces faces dans le plan de fissure""" import logging -from .geomsmesh import geompy -from .geomsmesh import geomPublish -from .geomsmesh import geomPublishInFather + from . import initLog -# ----------------------------------------------------------------------------- -# --- TORE -## --- faces 1/2 circulaires et leur centre, edges de ces faces dans le plan de fissure +from .geomsmesh import geompy +from .geomsmesh import geomPublishInFather def facesCirculaires(bloc, tore): """ @@ -41,59 +39,42 @@ def facesCirculaires(bloc, tore): faces = geompy.GetShapesOnShape(bloc, tore, geompy.ShapeType["FACE"], GEOM.ST_ON) - geomPublishInFather(initLog.debug, tore, faces[0], 'face0' ) - geomPublishInFather(initLog.debug, tore, faces[1], 'face1' ) - geomPublishInFather(initLog.debug, tore, faces[2], 'face2' ) - geomPublishInFather(initLog.debug, tore, faces[3], 'face3' ) - - centres = [None, None, None, None] - [v1,centres[0],v3] = geompy.ExtractShapes(faces[0], geompy.ShapeType["VERTEX"], True) - [v1,centres[1],v3] = geompy.ExtractShapes(faces[1], geompy.ShapeType["VERTEX"], True) - [v1,centres[2],v3] = geompy.ExtractShapes(faces[2], geompy.ShapeType["VERTEX"], True) - [v1,centres[3],v3] = geompy.ExtractShapes(faces[3], geompy.ShapeType["VERTEX"], True) + centres = list() + alledges = list() + for i_aux in range(4): + geomPublishInFather(initLog.debug, tore, faces[i_aux], 'face{}'.format(i_aux)) + [_,centre,_] = geompy.ExtractShapes(faces[i_aux], geompy.ShapeType["VERTEX"], True) + centres.append(centre) + geomPublishInFather(initLog.debug, faces[i_aux], centre, 'centre{}'.format(i_aux)) + alledges.append(geompy.ExtractShapes(faces[i_aux], geompy.ShapeType["EDGE"], True)) - geomPublishInFather(initLog.debug, faces[0], centres[0], 'centre0' ) - geomPublishInFather(initLog.debug, faces[1], centres[1], 'centre1' ) - geomPublishInFather(initLog.debug, faces[2], centres[2], 'centre2' ) - geomPublishInFather(initLog.debug, faces[3], centres[3], 'centre3' ) + dicoedge = dict() + edges = list() + reverses = list() - alledges = [None, None, None, None] - alledges[0] = geompy.ExtractShapes(faces[0], geompy.ShapeType["EDGE"], True) - alledges[1] = geompy.ExtractShapes(faces[1], geompy.ShapeType["EDGE"], True) - alledges[2] = geompy.ExtractShapes(faces[2], geompy.ShapeType["EDGE"], True) - alledges[3] = geompy.ExtractShapes(faces[3], geompy.ShapeType["EDGE"], True) + for i_aux, edgesface in enumerate(alledges): - dicoedge = {} - edges = [] - reverses = [] - for i in range(len(alledges)): - edgesface = alledges[i] - lenef = [] - for j in range(len(edgesface)): - props = geompy.BasicProperties(edgesface[j]) + lenef = list() + for edge in edgesface: + props = geompy.BasicProperties(edge) lenef.append(props[0]) - pass + maxlen = max(lenef) - for j in range(len(edgesface)): - if lenef[j] < maxlen: - edgid = geompy.GetSubShapeID(tore, edgesface[j]) + for j_aux, edge in enumerate(edgesface): + if lenef[j_aux] < maxlen: + edgid = geompy.GetSubShapeID(tore, edge) if not (edgid in dicoedge): - dicoedge[edgid] = edgesface[j] - edges.append(edgesface[j]) - named = 'edge_' + str(i) + '_' +str(j) - geomPublishInFather(initLog.debug, faces[i], edgesface[j], named) - vertices = geompy.ExtractShapes(edgesface[j], geompy.ShapeType["VERTEX"], False) - #firstVertex = geompy.GetFirstVertex(edgesface[j]) - if geompy.GetSubShapeID(tore, vertices[0]) != geompy.GetSubShapeID(tore, centres[i]): + dicoedge[edgid] = edge + edges.append(edge) + named = 'edge_{}_{}'.format(i_aux,j_aux) + geomPublishInFather(initLog.debug, faces[i_aux], edge, named) + vertices = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], False) + #firstVertex = geompy.GetFirstVertex(edge) + if geompy.GetSubShapeID(tore, vertices[0]) != geompy.GetSubShapeID(tore, centres[i_aux]): reverses.append(1) #print 'reversed ' + str(edgid) else: reverses.append(0) #print 'normal' + str(edgid) - pass - pass - pass - pass return faces, centres, edges, reverses - diff --git a/src/Tools/blocFissure/gmu/facesFissure.py b/src/Tools/blocFissure/gmu/facesFissure.py index bc76f8b9e..159641c9d 100644 --- a/src/Tools/blocFissure/gmu/facesFissure.py +++ b/src/Tools/blocFissure/gmu/facesFissure.py @@ -17,33 +17,34 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Faces fissure dans et hors tore, et edges face hors tore""" import logging -from .geomsmesh import geompy -from .geomsmesh import geomPublish -from .geomsmesh import geomPublishInFather + +import GEOM + from . import initLog -# ----------------------------------------------------------------------------- -# --- faces fissure dans et hors tore, et edges face hors tore +from .geomsmesh import geompy +from .geomsmesh import geomPublishInFather def facesFissure(blocp, faceFissure, extrusionDefaut, genint): - """ - extraction des faces de fissure dans et hors tore, des edges le long du tore et en paroi + """Extraction des faces de fissure dans et hors tore, des edges le long du tore et en paroi + @param faceFissure : la face de fissure avec la partie dans le tore elliptique et la partie externe @return (facefissintore, facefissoutore, edgeint, edgeext) """ logging.info('start') - [f0,f1] = geompy.ExtractShapes(faceFissure, geompy.ShapeType["FACE"], True) - ed0 = geompy.ExtractShapes(f0, geompy.ShapeType["EDGE"], True) - ed1 = geompy.ExtractShapes(f1, geompy.ShapeType["EDGE"], True) + [face_0,face_1] = geompy.ExtractShapes(faceFissure, geompy.ShapeType["FACE"], True) + ed0 = geompy.ExtractShapes(face_0, geompy.ShapeType["EDGE"], True) + ed1 = geompy.ExtractShapes(face_1, geompy.ShapeType["EDGE"], True) if len(ed0) > len(ed1): - facefissintore = f0 - facefissoutore = f1 + facefissintore = face_0 + facefissoutore = face_1 else: - facefissintore = f1 - facefissoutore = f0 + facefissintore = face_1 + facefissoutore = face_0 geomPublishInFather(initLog.debug, faceFissure, facefissintore,'facefissintore') geomPublishInFather(initLog.debug, faceFissure, facefissoutore,'facefissoutore') @@ -51,18 +52,18 @@ def facesFissure(blocp, faceFissure, extrusionDefaut, genint): edgeint = geompy.GetShapesOnShape(extrusionDefaut, facefissoutore, geompy.ShapeType["EDGE"], GEOM.ST_IN) edgeext = geompy.GetShapesOnShape(extrusionDefaut, facefissoutore, geompy.ShapeType["EDGE"], GEOM.ST_ON) - for i in range(len(edgeint)): - name = "edgeint_%d"%i - geomPublishInFather(initLog.debug, facefissoutore, edgeint[i],name) - for i in range(len(edgeext)): - name = "edgeext_%d"%i - geomPublishInFather(initLog.debug, facefissoutore, edgeext[i],name) + for i_aux, edge in enumerate(edgeint): + name = "edgeint_{}".format(i_aux) + geomPublishInFather(initLog.debug, facefissoutore, edge,name) + for i_aux, edge in enumerate(edgeext): + name = "edgeext_{}".format(i_aux) + geomPublishInFather(initLog.debug, facefissoutore, edge,name) - reverext = [] + reverext = list() if len(edgeext) > 1: vertices = geompy.ExtractShapes(genint, geompy.ShapeType["VERTEX"], False) - for i in range(len(edgeext)): - vertedge = geompy.ExtractShapes(edgeext[i], geompy.ShapeType["VERTEX"], False) + for edge in edgeext: + vertedge = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], False) if ((geompy.GetSubShapeID(blocp, vertedge[0]) == geompy.GetSubShapeID(blocp, vertices[0])) or (geompy.GetSubShapeID(blocp, vertedge[0]) == geompy.GetSubShapeID(blocp, vertices[1]))): reverext.append(0) diff --git a/src/Tools/blocFissure/gmu/facesToreInBloc.py b/src/Tools/blocFissure/gmu/facesToreInBloc.py index e68aaa539..456ce5762 100644 --- a/src/Tools/blocFissure/gmu/facesToreInBloc.py +++ b/src/Tools/blocFissure/gmu/facesToreInBloc.py @@ -17,19 +17,18 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Identification des faces tore et fissure dans le solide hors tore du bloc partitionné""" import logging -from .geomsmesh import geompy -from .geomsmesh import geomPublish -from .geomsmesh import geomPublishInFather + from . import initLog -# ----------------------------------------------------------------------------- -# --- identification des faces tore et fissure dans le solide hors tore du bloc partitionné +from .geomsmesh import geompy +from .geomsmesh import geomPublishInFather def facesToreInBloc(blocp, facefissoutore, facetore1, facetore2): - """ - identification des faces tore et fissure dans le bloc partitionné : sous shapes du bloc + """Identification des faces tore et fissure dans le bloc partitionné : sous shapes du bloc + @param blocp : bloc partitionné @param facefissoutore : la face de fissure externe au tore @param facetore1 : face du tore selon la génératrice @@ -47,4 +46,3 @@ def facesToreInBloc(blocp, facefissoutore, facetore1, facetore2): geomPublishInFather(initLog.debug, blocp, blocFaceTore2,'blocFaceTore2') return blocFaceFiss, blocFaceTore1, blocFaceTore2 - diff --git a/src/Tools/blocFissure/gmu/facesVolumesToriques.py b/src/Tools/blocFissure/gmu/facesVolumesToriques.py index af48c9560..8e85e933e 100644 --- a/src/Tools/blocFissure/gmu/facesVolumesToriques.py +++ b/src/Tools/blocFissure/gmu/facesVolumesToriques.py @@ -17,19 +17,18 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Tore : aces toriques et volumes du tore""" import logging + +from . import initLog + from .geomsmesh import geompy -from .geomsmesh import geomPublish from .geomsmesh import geomPublishInFather -from . import initLog + from .extractionOrientee import extractionOrientee from .getSubshapeIds import getSubshapeIds -# ----------------------------------------------------------------------------- -# --- TORE -# --- faces toriques et volumes du tore - def facesVolumesToriques(tore, plan, facesDefaut): """ Extraction des deux faces et volumes du tore partitionné, qui suivent la génératrice elliptique. @@ -43,28 +42,25 @@ def facesVolumesToriques(tore, plan, facesDefaut): normal = geompy.GetNormal(plan, centre) reference = geompy.MakeTranslationVector(centre, normal) - [facesInPlan, facesOutPlan, facesOnPlan] = extractionOrientee(plan, tore, reference, "FACE", 1.e-2, "faceTorePlan_") - [facesInSide, facesOutSide, facesOnSide] = extractionOrientee(facesDefaut, tore, reference, "FACE", 1.e-2, "faceTorePeau_") + [facesInPlan, facesOutPlan, _] = extractionOrientee(plan, tore, reference, "FACE", 1.e-2, "faceTorePlan_") facesIdInPlan = getSubshapeIds(tore, facesInPlan) facesIdOutPlan = getSubshapeIds(tore, facesOutPlan) + + [_, _, facesOnSide] = extractionOrientee(facesDefaut, tore, reference, "FACE", 1.e-2, "faceTorePeau_") facesIdOnSide = getSubshapeIds(tore, facesOnSide) - facesIdInSide = getSubshapeIds(tore, facesInSide) - facesIdOutSide = getSubshapeIds(tore, facesOutSide) - #facesIdInOutSide = facesIdInSide + facesIdOutSide + facetore1 = None - faceTore2 = None - for i, faceId in enumerate(facesIdInPlan): + for i_aux, faceId in enumerate(facesIdInPlan): if faceId not in facesIdOnSide: - facetore1 = facesInPlan[i] + facetore1 = facesInPlan[i_aux] break - for i, faceId in enumerate(facesIdOutPlan): + geomPublishInFather(initLog.debug, tore, facetore1, 'facetore1' ) + + facetore2 = None + for i_aux, faceId in enumerate(facesIdOutPlan): if faceId not in facesIdOnSide: - facetore2 = facesOutPlan[i] + facetore2 = facesOutPlan[i_aux] break - - #[facetore1,facetore2] = geompy.GetShapesOnShape(pipe0, tore, geompy.ShapeType["FACE"], GEOM.ST_ON) - - geomPublishInFather(initLog.debug, tore, facetore1, 'facetore1' ) geomPublishInFather(initLog.debug, tore, facetore2, 'facetore2' ) [volumeTore1, volumeTore2] = geompy.ExtractShapes(tore, geompy.ShapeType["SOLID"], True) diff --git a/src/Tools/blocFissure/gmu/findWireEndVertices.py b/src/Tools/blocFissure/gmu/findWireEndVertices.py index 7a26e950b..cf70523f0 100644 --- a/src/Tools/blocFissure/gmu/findWireEndVertices.py +++ b/src/Tools/blocFissure/gmu/findWireEndVertices.py @@ -17,67 +17,35 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Trouver les vertices aux extrémites d'un wire""" import logging -from .geomsmesh import geompy -from .geomsmesh import geomPublish -from .geomsmesh import geomPublishInFather + from . import initLog -# ----------------------------------------------------------------------------- -# --- trouver les vertices extremites d'un wire +from .geomsmesh import geompy + +from .findWireVertices import findWireVertices def findWireEndVertices(aWire, getNormals=False): - """ - trouver les vertices extremites d'un wire - calcul optionnel des tangentes. Attention à la tolérance qui peut être élevée (> 0.001) + """Trouver les vertices aux extrémites d'un wire + + Calcul optionnel des tangentes. Attention à la tolérance qui peut être élevée (> 0.001) """ logging.info("start") if geompy.NumberOfEdges(aWire) > 1: edges = geompy.ExtractShapes(aWire, geompy.ShapeType["EDGE"], False) else: edges = [aWire] - vertices = [] - idsubs = {} - shortList = [] - if getNormals: - normals = [] - idnorm = {} - shortNorm = [] - for edge in edges: - vert = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], False) - vertices += vert - if getNormals: - v0 = geompy.MakeVertexOnCurve(edge, 0.0) - n0 = geompy.MakeTangentOnCurve(edge, 0.0) - v1 = geompy.MakeVertexOnCurve(edge, 1.0) - n1 = geompy.MakeTangentOnCurve(edge, 1.0) - dist = geompy.MinDistance(v0, vert[0]) - logging.debug("distance %s", dist) - if dist < 1.e-2: - normals += [n0, n1] - else: - normals += [n1, n0] - for i, sub in enumerate(vertices): - subid = geompy.GetSubShapeID(aWire, sub) - if subid in list(idsubs.keys()): - idsubs[subid].append(sub) - else: - idsubs[subid] = [sub] - name='vertex%d'%i - geomPublishInFather(initLog.debug, aWire, sub, name) - if getNormals: - idnorm[subid] = normals[i] - name='norm%d'%i - geomPublishInFather(initLog.debug, aWire, normals[i], name) - logging.debug("idsubs: %s", idsubs) - for k, v in idsubs.items(): - if len(v) == 1: - shortList.append(v[0]) + + idsubs, idnorm = findWireVertices(aWire, edges, getNormals) + + shortList = list() + shortNorm = list() + for k_aux, sub in idsubs.items(): + if ( len(sub) == 1 ): + shortList.append(sub[0]) if getNormals: - shortNorm.append(idnorm[k]) - if getNormals: - return shortList, shortNorm - else: - return shortList + shortNorm.append(idnorm[k_aux]) + return shortList, shortNorm diff --git a/src/Tools/blocFissure/gmu/findWireIntermediateVertices.py b/src/Tools/blocFissure/gmu/findWireIntermediateVertices.py index 182a6c8cf..015f63667 100644 --- a/src/Tools/blocFissure/gmu/findWireIntermediateVertices.py +++ b/src/Tools/blocFissure/gmu/findWireIntermediateVertices.py @@ -17,63 +17,35 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Trouver les vertices intermédiaires d'un wire""" import logging -from .geomsmesh import geompy -from .geomsmesh import geomPublish -from .geomsmesh import geomPublishInFather + from . import initLog +from .geomsmesh import geompy + +from .findWireVertices import findWireVertices + # ----------------------------------------------------------------------------- # --- trouver les vertices intermediaires d'un wire def findWireIntermediateVertices(aWire, getNormals=False): - """ - trouver les vertices d'un wire qui ne sont pas aux extremités - calcul optionnel des tangentes. Attention à la tolérance qui peut être élevée (> 0.001) + """Trouver les vertices d'un wire qui ne sont pas aux extremités + + Calcul optionnel des tangentes. Attention à la tolérance qui peut être élevée (> 0.001) """ logging.info("start") edges = geompy.ExtractShapes(aWire, geompy.ShapeType["EDGE"], False) - vertices = [] - idsubs = {} - shortList = [] - if getNormals: - normals = [] - idnorm = {} - shortNorm = [] - for edge in edges: - vert = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], False) - vertices += vert - if getNormals: - v0 = geompy.MakeVertexOnCurve(edge, 0.0) - n0 = geompy.MakeTangentOnCurve(edge, 0.0) - v1 = geompy.MakeVertexOnCurve(edge, 1.0) - n1 = geompy.MakeTangentOnCurve(edge, 1.0) - dist = geompy.MinDistance(v0, vert[0]) - logging.debug("distance %s", dist) - if dist < 1.e-2: - normals += [n0, n1] - else: - normals += [n1, n0] - for i, sub in enumerate(vertices): - subid = geompy.GetSubShapeID(aWire, sub) - if subid in list(idsubs.keys()): - idsubs[subid].append(sub) - else: - idsubs[subid] = [sub] - name='vertex%d'%i - geomPublishInFather(initLog.debug, aWire, sub, name) - if getNormals: - idnorm[subid] = normals[i] - name='norm%d'%i - geomPublishInFather(initLog.debug, aWire, normals[i], name) - for k, v in idsubs.items(): - if len(v) > 1: - shortList.append(v[0]) + + idsubs, idnorm = findWireVertices(aWire, edges, getNormals) + + shortList = list() + shortNorm = list() + for k_aux, sub in idsubs.items(): + if ( len(sub) > 1 ): + shortList.append(sub[0]) if getNormals: - shortNorm.append(idnorm[k]) - if getNormals: - return shortList, shortNorm - else: - return shortList + shortNorm.append(idnorm[k_aux]) + return shortList, shortNorm diff --git a/src/Tools/blocFissure/gmu/findWireVertices.py b/src/Tools/blocFissure/gmu/findWireVertices.py new file mode 100644 index 000000000..17dc7d20f --- /dev/null +++ b/src/Tools/blocFissure/gmu/findWireVertices.py @@ -0,0 +1,69 @@ +# -*- coding: utf-8 -*- +# Copyright (C) 2014-2021 EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +"""Trouver les vertices d'un wire""" + +import logging + +from . import initLog + +from .geomsmesh import geompy +from .geomsmesh import geomPublishInFather + +def findWireVertices(aWire, edges, getNormals=False): + """Trouver les vertices d'un wire + + Calcul optionnel des tangentes. Attention à la tolérance qui peut être élevée (> 0.001) + """ + logging.info("start") + vertices = list() + idsubs = dict() + idnorm = dict() + if getNormals: + normals = list() + + for edge in edges: + vert = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], False) + vertices += vert + if getNormals: + vertex_0 = geompy.MakeVertexOnCurve(edge, 0.0) + tangente_0 = geompy.MakeTangentOnCurve(edge, 0.0) + tangente_1 = geompy.MakeTangentOnCurve(edge, 1.0) + dist = geompy.MinDistance(vertex_0, vert[0]) + logging.debug("distance %s", dist) + if dist < 1.e-2: + normals += [tangente_0, tangente_1] + else: + normals += [tangente_1, tangente_0] + + for nro, sub in enumerate(vertices): + subid = geompy.GetSubShapeID(aWire, sub) + if subid in list(idsubs.keys()): + idsubs[subid].append(sub) + else: + idsubs[subid] = [sub] + name='vertex{}'.format(nro) + geomPublishInFather(initLog.debug, aWire, sub, name) + if getNormals: + idnorm[subid] = normals[nro] + name='norm{}'.format(nro) + geomPublishInFather(initLog.debug, aWire, normals[nro], name) + logging.debug("idsubs: %s", idsubs) + + return idsubs, idnorm diff --git a/src/Tools/blocFissure/gmu/fissError.py b/src/Tools/blocFissure/gmu/fissError.py index 3765e1389..a8d6d493f 100644 --- a/src/Tools/blocFissure/gmu/fissError.py +++ b/src/Tools/blocFissure/gmu/fissError.py @@ -17,19 +17,18 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Message d'erreur""" class fissError(Exception): - """ - usage: + """ Usage: try: instructions() except: - raise fissError(traceback.extract_stack(),"mon message") + raise fissError(traceback.extract_stack(),"mon message") """ def __init__(self, pile, msg): - self.pile = pile + self.pile = pile self.msg = msg def __str__(self): - return 'msg=%s\npile=%s\n'%(self.msg, repr(self.pile)) - + return 'msg={}\npile={}\n'.format(self.msg, repr(self.pile)) diff --git a/src/Tools/blocFissure/gmu/fissureCoude.py b/src/Tools/blocFissure/gmu/fissureCoude.py index 1eed55827..48892cd62 100644 --- a/src/Tools/blocFissure/gmu/fissureCoude.py +++ b/src/Tools/blocFissure/gmu/fissureCoude.py @@ -17,19 +17,21 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Fissure dans un coude""" import os -from .geomsmesh import geompy, smesh -from .geomsmesh import geomPublish -from .geomsmesh import geomPublishInFather -from . import initLog - +import logging import math import GEOM import SALOMEDS import SMESH -import logging + +from . import initLog + +from .geomsmesh import geompy, smesh +from .geomsmesh import geomPublish +from .geomsmesh import geomPublishInFather from .fissureGenerique import fissureGenerique @@ -42,12 +44,12 @@ from .sortEdges import sortEdges O, OX, OY, OZ = triedreBase() class fissureCoude(fissureGenerique): - """ - problème de fissure du Coude : version de base - maillage hexa - """ + """Problème de fissure du Coude : version de base - maillage hexa""" nomProbleme = "fissureCoude" + longitudinale = None + circonferentielle = None + elliptique = None # --------------------------------------------------------------------------- def setParamGeometrieSaine(self): @@ -347,10 +349,8 @@ class fissureCoude(fissureGenerique): logging.info("genereShapeFissure %s", self.nomCas) logging.info("shapeFissureParams %s", shapeFissureParams) - angleCoude = geomParams['angleCoude'] r_cintr = geomParams['r_cintr'] l_tube_p1 = geomParams['l_tube_p1'] - l_tube_p2 = geomParams['l_tube_p2'] epais = geomParams['epais'] de = geomParams['de'] @@ -365,8 +365,6 @@ class fissureCoude(fissureGenerique): if 'elliptique' in shapeFissureParams: self.elliptique = shapeFissureParams['elliptique'] - - azimut = -azimut # axe inverse / ASCOUF axe = geompy.MakeTranslation(OY, -r_cintr, 0, -l_tube_p1) geomPublish(initLog.debug, axe,"axe") @@ -383,10 +381,8 @@ class fissureCoude(fissureGenerique): self.circonferentielle = False self.longitudinale = False if self.fissureLongue and not self.elliptique: - if abs(orientation) < 45 : - self.longitudinale = True - else: - self.circonferentielle = True + self.longitudinale = bool(abs(orientation) < 45) + self.circonferentielle = not bool(abs(orientation) < 45) nbp1 = 10 if self.circonferentielle: @@ -400,8 +396,8 @@ class fissureCoude(fissureGenerique): raybor = de/2. - epais rayint = raybor + profondeur rayext = raybor - profondeur/5.0 - lgfond = longueur -2*profondeur - angle = lgfond/(2*raybor) + lgfond = longueur -2.*profondeur + angle = lgfond/(2.*raybor) pb = geompy.MakeVertex(raybor, 0, 0) pi = geompy.MakeVertex(rayint, 0, 0) pbl = geompy.MakeRotation(pb, OZ, angle) @@ -592,7 +588,7 @@ class fissureCoude(fissureGenerique): geomPublish(initLog.debug, centre, 'centrefissPlace' ) edges = geompy.ExtractShapes(facefiss, geompy.ShapeType["EDGE"], True) - edgesTriees, minl, maxl = sortEdges(edges) + edgesTriees, _, _ = sortEdges(edges) edges = edgesTriees[:-1] # la plus grande correspond à arce, on l'elimine wiretube = geompy.MakeWire(edges) #wiretube = edgesTriees[-1] @@ -643,7 +639,7 @@ class fissureCoude(fissureGenerique): facefiss = geompy.MakeFaceWires([arce, arci], 0) geomPublish(initLog.debug, facefiss, 'facefissPlace' ) edges = geompy.ExtractShapes(facefiss, geompy.ShapeType["EDGE"], True) - edgesTriees, minl, maxl = sortEdges(edges) + edgesTriees, _, _ = sortEdges(edges) edgetube = edgesTriees[-1] # la plus grande correspond à arci wiretube = edgetube diff --git a/src/Tools/blocFissure/gmu/fusionMaillageAttributionDefaut.py b/src/Tools/blocFissure/gmu/fusionMaillageAttributionDefaut.py index db5aebc60..a509c0350 100644 --- a/src/Tools/blocFissure/gmu/fusionMaillageAttributionDefaut.py +++ b/src/Tools/blocFissure/gmu/fusionMaillageAttributionDefaut.py @@ -17,93 +17,85 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -""" -Created on Tue Jun 24 09:14:13 2014 +"""Groupe de quadrangles de face transformé en face géométrique par filling +Created on Tue Jun 24 09:14:13 2014 @author: I48174 (Olivier HOAREAU) """ import logging -from .geomsmesh import geompy -from .geomsmesh import smesh -from .geomsmesh import geomPublish -from .geomsmesh import geomPublishInFather -from . import initLog + import GEOM import SMESH +from .geomsmesh import geompy +from .geomsmesh import smesh + from .listOfExtraFunctions import createNewMeshesFromCorner from .listOfExtraFunctions import createLinesFromMesh -# ----------------------------------------------------------------------------- -# --- groupe de quadrangles de face transformé en face géométrique par filling - def fusionMaillageDefaut(maillageSain, maillageDefautCible, maillageInterneCible, zoneDefaut_skin, shapeDefaut, listOfCorners): - """ """ - # TODO: rédiger la docstring - - logging.info("start") - - facesNonCoupees = [] - facesCoupees = [] - maillagesNonCoupes = [] - maillagesCoupes = [] - - # On crée une liste contenant le maillage de chaque face. - listOfNewMeshes = createNewMeshesFromCorner(maillageDefautCible, listOfCorners) - - i = 0 - while i < len(listOfNewMeshes): - lines = createLinesFromMesh(listOfNewMeshes[i]) - setOfLines = [] - for line in lines: - # On possède l'information 'ID' de chaque noeud composant chaque - # ligne de la face. A partir de l'ID, on crée un vertex. Un - # ensemble de vertices constitue une ligne. Un ensemble de lignes - # constitue la face. - tmpCoords = [maillageDefautCible.GetNodeXYZ(node) for node in line] - tmpPoints = [geompy.MakeVertex(val[0], val[1], val[2]) for val in tmpCoords] - line = geompy.MakeInterpol(tmpPoints, False, False) - setOfLines.append(line) - - # A partir des lignes de la face, - # on recrée un objet GEOM temporaire par filling. - filling = geompy.MakeFilling(geompy.MakeCompound(setOfLines), 2, 5, 0.0001, 0.0001, 0, GEOM.FOM_Default, True) - #logging.debug("face de filling") - #geomPublish(initLog.debug, filling, 'filling_{0}'.format(i + 1)) - - tmpPartition = geompy.MakePartition([filling], [shapeDefaut], [], [], geompy.ShapeType["FACE"], 0, [], 0) - tmpExplodeRef = geompy.ExtractShapes(filling, geompy.ShapeType["EDGE"], True) - tmpExplodeNum = geompy.ExtractShapes(tmpPartition, geompy.ShapeType["EDGE"], True) - if len(tmpExplodeRef) == len(tmpExplodeNum): - logging.debug("face de filling non coupee") - geompy.addToStudy( filling, "faceNonCoupee_{0}".format(i + 1)) # doit etre publie pour critere OK plus bas - facesNonCoupees.append(filling) - maillagesNonCoupes.append(listOfNewMeshes[i]) - else: - logging.debug("face de filling coupee") - geompy.addToStudy( filling, "faceCoupee_{0}".format(i + 1)) - facesCoupees.append(filling) - maillagesCoupes.append(listOfNewMeshes[i]) - - i += 1 - - listOfInternMeshes = [maillageInterneCible] + [msh.GetMesh() for msh in maillagesNonCoupes] - - newMaillageInterne = smesh.Concatenate(listOfInternMeshes, 1, 1, 1e-05, False) - - facesEnTrop = [] - - criteres = [smesh.GetCriterion(SMESH.FACE, SMESH.FT_BelongToGenSurface, SMESH.FT_Undefined, face) for face in facesNonCoupees] - filtres = [smesh.GetFilterFromCriteria([critere]) for critere in criteres] - for i, filtre in enumerate(filtres): - filtre.SetMesh(maillageSain.GetMesh()) - faceEnTrop = maillageSain.GroupOnFilter(SMESH.FACE, 'faceEnTrop_{0}'.format(i + 1), filtre) - facesEnTrop.append(faceEnTrop) - - newZoneDefaut_skin = maillageSain.GetMesh().CutListOfGroups([zoneDefaut_skin], facesEnTrop, 'newZoneDefaut_skin') - - smesh.SetName(newMaillageInterne, 'newInternalBoundary') - - return newZoneDefaut_skin, newMaillageInterne - \ No newline at end of file + """Groupe de quadrangles de face transformé en face géométrique par filling""" + + logging.info("start") + + facesNonCoupees = list() + facesCoupees = list() + maillagesNonCoupes = list() + maillagesCoupes = list() + + # On crée une liste contenant le maillage de chaque face. + listOfNewMeshes = createNewMeshesFromCorner(maillageDefautCible, listOfCorners) + + i_aux = 0 + while i_aux < len(listOfNewMeshes): + lines = createLinesFromMesh(listOfNewMeshes[i_aux]) + setOfLines = list() + for line in lines: + # On possède l'information 'ID' de chaque noeud composant chaque + # ligne de la face. A partir de l'ID, on crée un vertex. Un + # ensemble de vertices constitue une ligne. Un ensemble de lignes + # constitue la face. + tmpCoords = [maillageDefautCible.GetNodeXYZ(node) for node in line] + tmpPoints = [geompy.MakeVertex(val[0], val[1], val[2]) for val in tmpCoords] + line = geompy.MakeInterpol(tmpPoints, False, False) + setOfLines.append(line) + + # A partir des lignes de la face, + # on recrée un objet GEOM temporaire par filling. + filling = geompy.MakeFilling(geompy.MakeCompound(setOfLines), 2, 5, 0.0001, 0.0001, 0, GEOM.FOM_Default, True) + #logging.debug("face de filling") + #geomPublish(initLog.debug, filling, 'filling_{0}'.format(i_aux+1)) + + tmpPartition = geompy.MakePartition([filling], [shapeDefaut], list(), list(), geompy.ShapeType["FACE"], 0, list(), 0) + tmpExplodeRef = geompy.ExtractShapes(filling, geompy.ShapeType["EDGE"], True) + tmpExplodeNum = geompy.ExtractShapes(tmpPartition, geompy.ShapeType["EDGE"], True) + if len(tmpExplodeRef) == len(tmpExplodeNum): + logging.debug("face de filling non coupee") + geompy.addToStudy( filling, "faceNonCoupee_{0}".format(i_aux+1)) # doit etre publie pour critere OK plus bas + facesNonCoupees.append(filling) + maillagesNonCoupes.append(listOfNewMeshes[i_aux]) + else: + logging.debug("face de filling coupee") + geompy.addToStudy( filling, "faceCoupee_{0}".format(i_aux+1)) + facesCoupees.append(filling) + maillagesCoupes.append(listOfNewMeshes[i_aux]) + i_aux += 1 + + listOfInternMeshes = [maillageInterneCible] + [msh.GetMesh() for msh in maillagesNonCoupes] + + newMaillageInterne = smesh.Concatenate(listOfInternMeshes, 1, 1, 1e-05, False) + + facesEnTrop = list() + criteres = [smesh.GetCriterion(SMESH.FACE, SMESH.FT_BelongToGenSurface, SMESH.FT_Undefined, face) for face in facesNonCoupees] + filtres = [smesh.GetFilterFromCriteria([critere]) for critere in criteres] + for i_aux, filtre in enumerate(filtres): + filtre.SetMesh(maillageSain.GetMesh()) + faceEnTrop = maillageSain.GroupOnFilter(SMESH.FACE, 'faceEnTrop_{0}'.format(i_aux+1), filtre) + facesEnTrop.append(faceEnTrop) + + newZoneDefaut_skin = maillageSain.GetMesh().CutListOfGroups([zoneDefaut_skin], facesEnTrop, 'newZoneDefaut_skin') + + smesh.SetName(newMaillageInterne, 'newInternalBoundary') + + return newZoneDefaut_skin, newMaillageInterne diff --git a/src/Tools/blocFissure/gmu/genereElemsFissureElliptique.py b/src/Tools/blocFissure/gmu/genereElemsFissureElliptique.py index d4d06b13a..a5bd42b36 100644 --- a/src/Tools/blocFissure/gmu/genereElemsFissureElliptique.py +++ b/src/Tools/blocFissure/gmu/genereElemsFissureElliptique.py @@ -17,26 +17,24 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Création élements géométriques fissure elliptique""" import logging +from . import initLog + from .geomsmesh import geompy from .geomsmesh import geomPublish from .geomsmesh import geomPublishInFather -from . import initLog from .toreFissure import toreFissure from .ellipsoideDefaut import ellipsoideDefaut from .rotTrans import rotTrans from .genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut -# ----------------------------------------------------------------------------- -# --- création élements géométriques fissure elliptique - def genereElemsFissureElliptique(shapeFissureParams, \ mailleur="MeshGems"): - """ - TODO: a completer - """ + """Création élements géométriques fissure elliptique""" + logging.info('start') centreDefaut = shapeFissureParams['centreDefaut'] @@ -51,7 +49,7 @@ def genereElemsFissureElliptique(shapeFissureParams, \ allonge = demiGrandAxe/demiPetitAxe rayonTore = demiPetitAxe/5.0 generatrice, _, Pipe_1, FaceFissure, Plane_1, Pipe1Part = toreFissure(demiPetitAxe, allonge, rayonTore) - ellipsoide = ellipsoideDefaut(demiPetitAxe, allonge, rayonTore) + ellipsoide = ellipsoideDefaut(demiPetitAxe, allonge) # --- positionnement sur le bloc defaut de generatrice, tore et plan fissure diff --git a/src/Tools/blocFissure/gmu/genereMeshCalculZoneDefaut.py b/src/Tools/blocFissure/gmu/genereMeshCalculZoneDefaut.py index fc1a68c88..ceff2c22f 100644 --- a/src/Tools/blocFissure/gmu/genereMeshCalculZoneDefaut.py +++ b/src/Tools/blocFissure/gmu/genereMeshCalculZoneDefaut.py @@ -17,13 +17,13 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Maillage face de fissure pour identification zone de défaut""" import logging -from .geomsmesh import smesh + from salome.smesh import smeshBuilder -# ----------------------------------------------------------------------------- -# --- maillage face de fissure pour identification zone de defaut +from .geomsmesh import smesh def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize, \ mailleur="MeshGems"): @@ -46,7 +46,8 @@ def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize, \ -SetQuadAllowed = permission quadrangle dans maillage triangle -On récupère les coordonnées de chaque noeud de la fissure qu'on stocke - dans une liste sous la forme : [X0, Y0, Z0, ..., Xn, Yn, Zn]""" + dans une liste sous la forme : [X0, Y0, Z0, ..., Xn, Yn, Zn] + """ logging.info('start') diff --git a/src/Tools/blocFissure/gmu/geomsmesh.py b/src/Tools/blocFissure/gmu/geomsmesh.py index 3f923ebd1..50c900d00 100644 --- a/src/Tools/blocFissure/gmu/geomsmesh.py +++ b/src/Tools/blocFissure/gmu/geomsmesh.py @@ -17,10 +17,7 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # - -import logging -#logging.info('start') -from . import initLog +"""Publications dans salome""" import salome salome.salome_init() @@ -31,13 +28,14 @@ geompy = geomBuilder.New() from salome.smesh import smeshBuilder smesh = smeshBuilder.New() -# logging.debug("initialisation de geompy et smesh OK") +from . import initLog def geomPublish(level,aShape, aName): + """Publication d'un objet""" if initLog.getLogLevel() <= level: geompy.addToStudy(aShape, aName) - + def geomPublishInFather(level, aFather, aShape, aName): + """Publication d'un objet sous son ascendant""" if initLog.getLogLevel() <= level: geompy.addToStudyInFather(aFather, aShape, aName) - \ No newline at end of file diff --git a/src/Tools/blocFissure/gmu/getCentreFondFiss.py b/src/Tools/blocFissure/gmu/getCentreFondFiss.py index 14b82e5ed..709343082 100644 --- a/src/Tools/blocFissure/gmu/getCentreFondFiss.py +++ b/src/Tools/blocFissure/gmu/getCentreFondFiss.py @@ -17,31 +17,34 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Identification du centre de fond de fissure,""" import logging +import bisect + +from . import initLog + from .geomsmesh import geompy from .geomsmesh import geomPublish from .geomsmesh import geomPublishInFather -from . import initLog -import bisect publie = False def getCentreFondFiss(shapesFissure): - """ - identification du centre de fond de fissure, + """Identification du centre de fond de fissure, + transformation fond de fissure en edge unique (seulement pour la procédure construitFissureGenerale). On distingue le cas d'utilisation de la procédure insereFissureLongue par le nombre d'éléments de shapesFissure. """ global publie logging.debug("start") - + fondFiss = shapesFissure[4] # groupe d'edges de fond de fissure if len(shapesFissure) == 6: # procédure construitFissureGenerale, et edge fond de fissure fournie explicitement edgeFondExt = shapesFissure[5] else: edgeFondExt = None - + if len(shapesFissure) > 6: # procédure insereFissureLongue (fissure plane, plusieurs edges sur le fond de fissure) centreFondFiss = shapesFissure[1] tgtCentre = None @@ -57,7 +60,7 @@ def getCentreFondFiss(shapesFissure): aWire = geompy.MakeWire([fondFiss], 1e-07) if not publie: geomPublish(initLog.debug, aWire, "wireFondFissExt") - + lgWire = geompy.BasicProperties(aWire)[0] edges = geompy.ExtractShapes(aWire, geompy.ShapeType["EDGE"], True) lgEdges = [geompy.BasicProperties(ed)[0] for ed in edges] @@ -71,7 +74,7 @@ def getCentreFondFiss(shapesFissure): logging.debug("lgsumEdges %s", lgSumEd) logging.debug("id edge: %s, lgOnEdge: %s, lgEdge: %s",iedr, lgOnEdge, lgEdges[iedr]) if iedr > 0: # il y a une edge avant celle du milieu - if geompy.MinDistance(edges[iedr-1], geompy.MakeVertexOnCurve(edges[iedr], 0.0 )) < 1.e-3: # edge orientée croissante + if geompy.MinDistance(edges[iedr-1], geompy.MakeVertexOnCurve(edges[iedr], 0.0 )) < 1.e-3: # edge orientée croissante centreFondFiss = geompy.MakeVertexOnCurve(edges[iedr], lgOnEdge/lgEdges[iedr]) else: centreFondFiss = geompy.MakeVertexOnCurve(edges[iedr], 1.0 - lgOnEdge/lgEdges[iedr]) @@ -84,7 +87,7 @@ def getCentreFondFiss(shapesFissure): centreFondFiss = geompy.MakeVertexOnCurve(edges[iedr], lgOnEdge/lgEdges[iedr]) geomPublishInFather(initLog.debug,aWire, centreFondFiss, "centreFondFiss") tgtCentre = geompy.MakeTangentOnCurve(edges[iedr], lgOnEdge/ lgEdges[iedr]) - + if edgeFondExt is None: # fond de fissure non fourni explicitement sous forme d'edge try: edgeFondExt = geompy.MakeEdgeWire(aWire, 0.0005, 1e-07) @@ -93,6 +96,7 @@ def getCentreFondFiss(shapesFissure): edgeFondExt = None if not publie and edgeFondExt is not None: geomPublish(initLog.debug, edgeFondExt, "edgeFondExt") - + publie = True + return edgeFondExt, centreFondFiss, tgtCentre diff --git a/src/Tools/blocFissure/gmu/getSubshapeIds.py b/src/Tools/blocFissure/gmu/getSubshapeIds.py index 7b0468825..f2408b8cc 100644 --- a/src/Tools/blocFissure/gmu/getSubshapeIds.py +++ b/src/Tools/blocFissure/gmu/getSubshapeIds.py @@ -17,20 +17,18 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Transformation d'une liste de subshapes en une liste d'Id""" import logging -from .geomsmesh import geompy -# ----------------------------------------------------------------------------- -# --- transformation d'une liste de subshapes en une liste d'Id +from .geomsmesh import geompy def getSubshapeIds(obj, subshapes): - """ - transformation d'une liste de subshapes en une liste d'Id - """ + """Transformation d'une liste de subshapes en une liste d'Id""" logging.debug("start") - subshapesId = [] + subshapesId = list() for sub in subshapes: subshapesId.append(geompy.GetSubShapeID(obj, sub)) logging.debug("subshapesId=%s", subshapesId) + return subshapesId diff --git a/src/Tools/blocFissure/gmu/identifieElementsFissure.py b/src/Tools/blocFissure/gmu/identifieElementsFissure.py index d15aeb098..557c2298d 100644 --- a/src/Tools/blocFissure/gmu/identifieElementsFissure.py +++ b/src/Tools/blocFissure/gmu/identifieElementsFissure.py @@ -17,17 +17,21 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Identification edges fond de fissure, edges pipe sur la face de fissure, +edges prolongées +edges internes communes pipe et fissure, points communs edges fissure peau et edges circulaires +""" import logging +from . import initLog + from .geomsmesh import geompy -from .geomsmesh import geomPublish from .geomsmesh import geomPublishInFather -from . import initLog from .extractionOrientee import extractionOrientee from .extractionOrienteeMulti import extractionOrienteeMulti - + def identifieElementsFissure(ifil, facesDefaut, partitionPeauFissFond, edgesPipeFiss, edgesFondFiss, aretesVivesC, fillingFaceExterne, centreFondFiss): @@ -44,34 +48,32 @@ def identifieElementsFissure(ifil, facesDefaut, partitionPeauFissFond, geomPublishInFather(initLog.debug, partitionPeauFissFond, edgesPipeC, "edgesPipeFiss") edgesFondC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesFondFiss)) geomPublishInFather(initLog.debug, partitionPeauFissFond, edgesFondC, "edgesFondFiss") - + if aretesVivesC is None: - [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3) - [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3) + [edgesInside, _, _] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3) + [facesInside, _, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3) else: - [edgesInside, edgesOutside, edgesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3) - [facesInside, facesOutside, facesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3) - + [edgesInside, _, _] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3) + [facesInside, _, facesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3) + edgesPipeIn = geompy.GetSharedShapesMulti([edgesPipeC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"]) - verticesPipePeau = [] + verticesPipePeau = list() - for i, edge in enumerate(edgesPipeIn): + for i_aux, edge in enumerate(edgesPipeIn): try: vertices = geompy.GetSharedShapesMulti([edge, geompy.MakeCompound(facesOnside)], geompy.ShapeType["VERTEX"]) verticesPipePeau.append(vertices[0]) - name = "edgePipeIn%d"%i + name = "edgePipeIn{}".format(i_aux) geomPublishInFather(initLog.debug, partitionPeauFissFond, edge, name) - name = "verticePipePeau%d"%i + name = "verticePipePeau{}".format(i_aux) geomPublishInFather(initLog.debug, partitionPeauFissFond, vertices[0], name) - logging.debug("edgePipeIn%s coupe les faces OnSide", i) + logging.debug("edgePipeIn%s coupe les faces OnSide", i_aux) except: - logging.debug("edgePipeIn%s ne coupe pas les faces OnSide", i) + logging.debug("edgePipeIn%s ne coupe pas les faces OnSide", i_aux) - edgesFondIn =[] - if len(verticesPipePeau) > 0: # au moins une extrémité du pipe sur cette face de peau - #tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesOutside)], geompy.ShapeType["EDGE"]) - #edgesFondOut = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3] + edgesFondIn = list() + if verticesPipePeau: # au moins une extrémité du pipe sur cette face de peau tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"]) edgesFondIn = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3] - return (edgesPipeIn, verticesPipePeau, edgesFondIn, facesInside, facesOnside) \ No newline at end of file + return (edgesPipeIn, verticesPipePeau, edgesFondIn, facesInside, facesOnside) diff --git a/src/Tools/blocFissure/gmu/identifieElementsGeometriquesPeau.py b/src/Tools/blocFissure/gmu/identifieElementsGeometriquesPeau.py index f5a7e255d..5c4f021ce 100644 --- a/src/Tools/blocFissure/gmu/identifieElementsGeometriquesPeau.py +++ b/src/Tools/blocFissure/gmu/identifieElementsGeometriquesPeau.py @@ -17,6 +17,7 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Identification des éléments géométriques de la face de peau""" import logging @@ -30,8 +31,7 @@ def identifieElementsGeometriquesPeau(ifil, partitionPeauFissFond, edgesPipeFiss edgesFondFiss, wireFondFiss, aretesVivesC, \ facesDefaut, centreFondFiss, rayonPipe, \ aretesVivesCoupees): - """ - """ + """Identification des éléments géométriques de la face de peau""" logging.info('start') fillingFaceExterne = facesDefaut[ifil] @@ -40,17 +40,18 @@ def identifieElementsGeometriquesPeau(ifil, partitionPeauFissFond, edgesPipeFiss # --- identification edges fond de fissure, edges pipe sur la face de fissure, edges prolongées # edges internes communes pipe et fissure, points communs edges fissure peau et edges circulaires - (edgesPipeIn, verticesPipePeau, edgesFondIn, facesInside, facesOnside) = identifieElementsFissure(ifil, facesDefaut, partitionPeauFissFond, - edgesPipeFiss, edgesFondFiss, aretesVivesC, - fillingFaceExterne, centreFondFiss) + (edgesPipeIn, verticesPipePeau, edgesFondIn, facesInside, facesOnside) = \ + identifieElementsFissure(ifil, facesDefaut, partitionPeauFissFond, \ + edgesPipeFiss, edgesFondFiss, aretesVivesC, \ + fillingFaceExterne, centreFondFiss) # --- elements débouchants (intersection pipe et peau), indexés selon les edges du fond de fissure (edgesFondIn) (verticesEdgesFondIn, pipexts, cercles, - facesFissExt, edgesFissExtPeau, edgesFissExtPipe) = identifieElementsDebouchants(ifil, facesDefaut, partitionPeauFissFond, - edgesFondIn, edgesFondFiss, wireFondFiss, - aretesVivesC, fillingFaceExterne, - edgesPipeIn, verticesPipePeau, rayonPipe, + facesFissExt, edgesFissExtPeau, edgesFissExtPipe) = identifieElementsDebouchants(ifil, facesDefaut, partitionPeauFissFond, \ + edgesFondIn, edgesFondFiss, wireFondFiss, \ + aretesVivesC, fillingFaceExterne, \ + edgesPipeIn, verticesPipePeau, rayonPipe, \ facesInside, facesOnside) # --- pour les faces de peau sans extremité débouchante de fissure, il faut recenser les edges de fissure sur la face de peau @@ -60,16 +61,16 @@ def identifieElementsGeometriquesPeau(ifil, partitionPeauFissFond, edgesPipeFiss # --- inventaire des faces de peau : face de peau percée du pipe, extrémités du pipe - (facePeau, facesPeauSorted, edgesPeauFondIn) = identifieFacesPeau(ifil, verticesPipePeau, facesOnside, wireFondFiss, - verticesEdgesFondIn, pipexts, cercles, + (facePeau, facesPeauSorted, edgesPeauFondIn) = identifieFacesPeau(ifil, verticesPipePeau, facesOnside, wireFondFiss, \ + verticesEdgesFondIn, pipexts, cercles, \ fillingFaceExterne, centreFondFiss) # --- identification précise des edges et disques des faces de peau selon index extremité fissure - (endsEdgeFond, facesPipePeau, edgeRadFacePipePeau, - edgesCircPeau, verticesCircPeau, groupEdgesBordPeau, - bordsVifs, edgesFissurePeau, aretesVivesCoupees) = identifieEdgesPeau(edgesFissExtPipe, verticesPipePeau, facePeau, facesPeauSorted, - edgesPeauFondIn, fillingFaceExterne, aretesVivesC, aretesVivesCoupees) + (endsEdgeFond, facesPipePeau, edgeRadFacePipePeau, edgesCircPeau, verticesCircPeau, groupEdgesBordPeau, \ + bordsVifs, edgesFissurePeau, aretesVivesCoupees) = \ + identifieEdgesPeau(edgesFissExtPipe, verticesPipePeau, facePeau, facesPeauSorted, \ + edgesPeauFondIn, fillingFaceExterne, aretesVivesC, aretesVivesCoupees) dataPPFF = dict(endsEdgeFond = endsEdgeFond, # pour chaque face [points edge fond de fissure aux débouchés du pipe] facesPipePeau = facesPipePeau, # pour chaque face [faces du pipe débouchantes] @@ -87,4 +88,3 @@ def identifieElementsGeometriquesPeau(ifil, partitionPeauFissFond, edgesPipeFiss ) return dataPPFF, aretesVivesCoupees - diff --git a/src/Tools/blocFissure/gmu/identifieFacesEdgesFissureExterne.py b/src/Tools/blocFissure/gmu/identifieFacesEdgesFissureExterne.py index 65cbd3890..43ad593b7 100644 --- a/src/Tools/blocFissure/gmu/identifieFacesEdgesFissureExterne.py +++ b/src/Tools/blocFissure/gmu/identifieFacesEdgesFissureExterne.py @@ -17,31 +17,36 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Identification des faces et edges de fissure externe pour maillage""" import logging +from . import initLog + from .geomsmesh import geompy from .geomsmesh import geomPublish from .geomsmesh import geomPublishInFather -from . import initLog def identifieFacesEdgesFissureExterne(fsFissuExt, edFisExtPe, edFisExtPi, edgesPipeFiss): - """identification des faces et edges de fissure externe pour maillage""" + """Identification des faces et edges de fissure externe pour maillage""" logging.info('start') - logging.debug("---------------------------- fsFissuExt : {} ".format(fsFissuExt)) + texte = "---------------------------- fsFissuExt : {} ".format(fsFissuExt) + logging.debug(texte) facesFissExt = list() edgesFissExtPeau = list() edgesFissExtPipe = list() - for ifil in range(len(fsFissuExt)): # TODO: éliminer les doublons (comparer tous les vertices triés, avec mesure de distance ?) - facesFissExt += fsFissuExt[ifil] + for ifil, face in enumerate(fsFissuExt): # éliminer les doublons (comparer tous les vertices triés, avec mesure de distance ?) + facesFissExt += face edgesFissExtPeau += edFisExtPe[ifil] edgesFissExtPipe += edFisExtPi[ifil] - logging.debug("---------------------------- identification faces de fissure externes au pipe : {}".format(len(facesFissExt))) + texte = "---------------------------- identification faces de fissure externes au pipe : {}".format(len(facesFissExt)) + logging.debug(texte) # regroupement des faces de fissure externes au pipe. if not facesFissExt: - logging.info("---------------------------- fsFissuExt : {} ".format(fsFissuExt)) + texte = "---------------------------- fsFissuExt : {} ".format(fsFissuExt) + logging.info(texte) raise Exception("stop identifieFacesEdgesFissureExterne ; aucune face de fissure externe au pipe n'a été trouvée.") elif len(facesFissExt) > 1: @@ -49,17 +54,20 @@ def identifieFacesEdgesFissureExterne(fsFissuExt, edFisExtPe, edFisExtPi, edgesP edgesPipeFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesPipeFiss)) # edgesFissExtPipe peut ne pas couvrir toute la longueur # edgesPeauFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesFissExtPeau)) # il peut manquer des edges de faceFissureExterne en contact avec la peau dans edgesFissExtPeau - (isDone, closedFreeBoundaries, openFreeBoundaries) = geompy.GetFreeBoundary(faceFissureExterne) + (_, closedFreeBoundaries, _) = geompy.GetFreeBoundary(faceFissureExterne) edgesBordFFE = list() for bound in closedFreeBoundaries: edgesBordFFE += geompy.ExtractShapes(bound, geompy.ShapeType["EDGE"], False) edgesBordFFEid = [ (ed,geompy.GetSubShapeID(faceFissureExterne, ed)) for ed in edgesBordFFE] - logging.debug("edgesBordFFEid {}".format(edgesBordFFEid)) + texte = "edgesBordFFEid {}".format(edgesBordFFEid) + logging.debug(texte) edgesPPE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False) edgesPPEid = [ geompy.GetSubShapeID(faceFissureExterne, ed) for ed in edgesPPE] - logging.debug("edgesPPEid {}".format(edgesPPEid)) + texte = "edgesPPEid {}".format(edgesPPEid) + logging.debug(texte) edgesPFE = [ edid[0] for edid in edgesBordFFEid if edid[1] not in edgesPPEid] # on garde toutes les edges de bord non en contact avec le pipe - logging.debug("edgesPFE {}".format(edgesPFE)) + texte = "edgesPFE {}".format(edgesPFE) + logging.debug(texte) edgesPeauFissureExterneC = geompy.MakeCompound(edgesPFE) else: diff --git a/src/Tools/blocFissure/gmu/identifieFacesPeau.py b/src/Tools/blocFissure/gmu/identifieFacesPeau.py index 9511854d2..3ea6da9e4 100644 --- a/src/Tools/blocFissure/gmu/identifieFacesPeau.py +++ b/src/Tools/blocFissure/gmu/identifieFacesPeau.py @@ -17,13 +17,14 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Inventaire des faces de peau""" import logging +from . import initLog + from .geomsmesh import geompy from .geomsmesh import geomPublish -from .geomsmesh import geomPublishInFather -from . import initLog from .sortFaces import sortFaces from .extractionOrientee import extractionOrientee @@ -31,69 +32,64 @@ from .extractionOrientee import extractionOrientee def identifieFacesPeau(ifil, verticesPipePeau, facesOnside, wireFondFiss, verticesEdgesFondIn, pipexts, cercles, fillingFaceExterne, centreFondFiss): - """ - inventaire des faces de peau : face de peau percée du pipe, extrémités du pipe + """Inventaire des faces de peau : face de peau percée du pipe, extrémités du pipe + La partition avec le pipe peut créer un vertex (et un edge) de trop sur le cercle projeté, quand le cercle est très proche de la face. dans ce cas, la projection du cercle sur la face suivie d'une partition permet d'éviter le point en trop """ logging.info('start') - + facesAndFond = facesOnside facesAndFond.append(wireFondFiss) try: partitionPeauByPipe = geompy.MakePartition(facesAndFond, pipexts, [], [], geompy.ShapeType["FACE"], 0, [], 1) except: logging.debug("probleme partition face pipe, contournement avec MakeSection") - sections = [] + sections = list() for pipext in pipexts: sections.append(geompy.MakeSection(facesOnside[0], pipext)) partitionPeauByPipe = geompy.MakePartition(facesAndFond, sections, [], [], geompy.ShapeType["FACE"], 0, [], 1) - + # contrôle edge en trop sur edges circulaires if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau - edgeEnTrop = [] + edgeEnTrop = list() outilPart = pipexts facesPeau = geompy.ExtractShapes(partitionPeauByPipe, geompy.ShapeType["FACE"], False) - facesPeauSorted, minsur, maxsurf = sortFaces(facesPeau) - for i, face in enumerate(facesPeauSorted[:-1]): # on ne teste que la ou les petites faces "circulaires" + facesPeauSorted, _, _ = sortFaces(facesPeau) + for face in facesPeauSorted[:-1]: # on ne teste que la ou les petites faces "circulaires" nbv = geompy.NumberOfEdges(face) logging.debug("nombre d'edges sur face circulaire: %s", nbv) - if nbv > 3: - edgeEnTrop.append(True) # TODO : distinguer les cas avec deux faces circulaires dont l'une est correcte - else: - edgeEnTrop.append(False) + edgeEnTrop.append(bool(nbv > 3)) # TODO : distinguer les cas avec deux faces circulaires dont l'une est correcte refaire = sum(edgeEnTrop) if refaire > 0: - dc = [(geompy.MinDistance(verticesEdgesFondIn[0], fac), i) for i, fac in enumerate(facesPeauSorted[:-1])] - dc.sort() - logging.debug("dc sorted: %s", dc) - i0 = dc[0][1] # indice de facesPeauSorted qui correspond à verticesEdgesFondIn[0], donc 0 pour cercles - direct = (i0 == 0) - for i, bad in enumerate(edgeEnTrop): + l_aux = [(geompy.MinDistance(verticesEdgesFondIn[0], fac), i_aux) for i_aux, fac in enumerate(facesPeauSorted[:-1])] + l_aux.sort() + logging.debug("l_aux sorted: %s", l_aux) + direct = bool(l_aux[0][1] == 0) # l_aux[0][1] = indice de facesPeauSorted qui correspond à verticesEdgesFondIn[0], donc 0 pour cercles + for i_aux, bad in enumerate(edgeEnTrop): if direct: - j = i + j_aux = i_aux else: - j = 1-i + j_aux = 1-i_aux if bad: - outilPart[j] = geompy.MakeProjection(cercles[j],facesOnside[0]) - pass + outilPart[j_aux] = geompy.MakeProjection(cercles[j_aux],facesOnside[0]) partitionPeauByPipe = geompy.MakePartition(facesAndFond, outilPart, [], [], geompy.ShapeType["FACE"], 0, [], 1) - pass - - name="partitionPeauByPipe%d"%ifil + + name="partitionPeauByPipe{}".format(ifil) geomPublish(initLog.debug, partitionPeauByPipe, name) - [edgesPeauFondIn, edgesPeauFondOut, edgesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "EDGE", 1.e-3) - [facesPeauFondIn, facesPeauFondOut, facesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "FACE", 1.e-3) - - if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau - facesPeauSorted, minsur, maxsurf = sortFaces(facesPeauFondOn) + [edgesPeauFondIn, _, _] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "EDGE", 1.e-3) + [_, _, facesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "FACE", 1.e-3) + + if verticesPipePeau: # --- au moins une extrémité du pipe sur cette face de peau + facesPeauSorted, _, _ = sortFaces(facesPeauFondOn) facePeau = facesPeauSorted[-1] # la plus grande face else: facePeau =geompy.MakePartition(facesPeauFondOn, [], [], [], geompy.ShapeType["FACE"], 0, [], 1) facesPeauSorted = [facePeau] - name="facePeau%d"%ifil + + name="facePeau{}".format(ifil) geomPublish(initLog.debug, facePeau, name) - return (facePeau, facesPeauSorted, edgesPeauFondIn) \ No newline at end of file + return (facePeau, facesPeauSorted, edgesPeauFondIn) diff --git a/src/Tools/blocFissure/gmu/initEtude.py b/src/Tools/blocFissure/gmu/initEtude.py index 1855cbe6e..58a9b68eb 100644 --- a/src/Tools/blocFissure/gmu/initEtude.py +++ b/src/Tools/blocFissure/gmu/initEtude.py @@ -17,12 +17,10 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Création d'une nouvelle étude""" import logging -myStudy = None def initEtude(): - """ - creation nouvelle etude salome - """ + """Création nouvelle etude salome""" from . import geomsmesh diff --git a/src/Tools/blocFissure/gmu/initLog.py b/src/Tools/blocFissure/gmu/initLog.py index b9e13cbea..7fa3c7f5a 100644 --- a/src/Tools/blocFissure/gmu/initLog.py +++ b/src/Tools/blocFissure/gmu/initLog.py @@ -17,6 +17,7 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Initialisations des impressions""" import logging import os @@ -34,6 +35,7 @@ ch = None fh = None def setLogger(logfile, level, formatter): + """setLogger""" global ch, fh rootLogger = logging.getLogger('') if fh is not None: @@ -53,9 +55,9 @@ def setLogger(logfile, level, formatter): rootLogger.addHandler(ch) ch.setFormatter(formatter) rootLogger.setLevel(level) - - + def setDebug(logfile=None): + """setDebug""" global loglevel loglevel = debug level = logging.DEBUG @@ -64,6 +66,7 @@ def setDebug(logfile=None): logging.info('start Debug %s', loglevel) def setVerbose(logfile=None): + """setVerbose""" global loglevel loglevel = info level = logging.INFO @@ -72,28 +75,32 @@ def setVerbose(logfile=None): logging.info('start Verbose %s', loglevel) def setRelease(logfile=None): + """setRelease""" global loglevel loglevel = warning level = logging.WARNING formatter = logging.Formatter('%(funcName)s[%(lineno)d] %(message)s') setLogger(logfile, level, formatter) logging.warning('start Release %s', loglevel) - + def setUnitTests(logfile=None): + """setUnitTests""" global loglevel loglevel = critical level = logging.CRITICAL formatter = logging.Formatter('%(funcName)s[%(lineno)d] %(message)s') setLogger(logfile, level, formatter) logging.critical('start UnitTests %s', loglevel) - + def setPerfTests(logfile=None): + """setPerfTests""" global loglevel loglevel = critical level = logging.CRITICAL formatter = logging.Formatter('%(funcName)s[%(lineno)d] %(message)s') setLogger(logfile, level, formatter) logging.info('start PerfTests %s', loglevel) - + def getLogLevel(): + """getLogLevel""" return loglevel diff --git a/src/Tools/blocFissure/gmu/insereFissureElliptique.py b/src/Tools/blocFissure/gmu/insereFissureElliptique.py index 3b7e36323..3f1a60e07 100644 --- a/src/Tools/blocFissure/gmu/insereFissureElliptique.py +++ b/src/Tools/blocFissure/gmu/insereFissureElliptique.py @@ -22,14 +22,9 @@ import os import logging + import salome -from .geomsmesh import geompy -from .geomsmesh import geomPublish -from .geomsmesh import geomPublishInFather -from . import initLog -from .geomsmesh import smesh import SMESH -import math from .partitionBlocDefaut import partitionBlocDefaut from .facesVolumesToriques import facesVolumesToriques @@ -50,17 +45,15 @@ from .putName import putName def insereFissureElliptique(geometriesSaines, maillagesSains, \ shapesFissure, shapeFissureParams, \ maillageFissureParams, elementsDefaut, step=-1): - """ - TODO: a completer - """ + """procedure complete fissure elliptique""" logging.info('start') - geometrieSaine = geometriesSaines[0] + #geometrieSaine = geometriesSaines[0] maillageSain = maillagesSains[0] isHexa = maillagesSains[1] - shapeDefaut = shapesFissure[0] - tailleDefaut = shapesFissure[2] - pipe0 = shapesFissure[4] + #shapeDefaut = shapesFissure[0] + #tailleDefaut = shapesFissure[2] + #pipe0 = shapesFissure[4] gener1 = shapesFissure[5] pipe1 = shapesFissure[6] facefis1 = shapesFissure[7] @@ -68,12 +61,12 @@ def insereFissureElliptique(geometriesSaines, maillagesSains, \ ellipsoide1 = shapesFissure[9] - demiGrandAxe = shapeFissureParams['demiGrandAxe'] - demiPetitAxe = shapeFissureParams['demiPetitAxe'] - orientation = shapeFissureParams['orientation'] + #demiGrandAxe = shapeFissureParams['demiGrandAxe'] + #demiPetitAxe = shapeFissureParams['demiPetitAxe'] + #orientation = shapeFissureParams['orientation'] nomRep = maillageFissureParams['nomRep'] - nomFicSain = maillageFissureParams['nomFicSain'] + #nomFicSain = maillageFissureParams['nomFicSain'] nomFicFissure = maillageFissureParams['nomFicFissure'] nbsegExt = maillageFissureParams['nbsegExt'] # 5 @@ -84,18 +77,18 @@ def insereFissureElliptique(geometriesSaines, maillagesSains, \ nbsegFis = maillageFissureParams['nbsegFis'] # 20 lensegEllipsoide = maillageFissureParams['lensegEllipso'] # 1.0 - fichierMaillageSain = os.path.join(nomRep, '{}.med'.format(nomFicSain)) + #fichierMaillageSain = os.path.join(nomRep, '{}.med'.format(nomFicSain)) fichierMaillageFissure = os.path.join(nomRep, '{}.med'.format(nomFicFissure)) facesDefaut = elementsDefaut[0] - centreDefaut = elementsDefaut[1] - normalDefaut = elementsDefaut[2] + #centreDefaut = elementsDefaut[1] + #normalDefaut = elementsDefaut[2] extrusionDefaut = elementsDefaut[3] dmoyen = elementsDefaut[4] - bordsPartages = elementsDefaut[5] - fillconts = elementsDefaut[6] - idFilToCont = elementsDefaut[7] - maillageSain = elementsDefaut[8] + #bordsPartages = elementsDefaut[5] + #fillconts = elementsDefaut[6] + #idFilToCont = elementsDefaut[7] + #maillageSain = elementsDefaut[8] internalBoundary = elementsDefaut[9] zoneDefaut = elementsDefaut[10] zoneDefaut_skin = elementsDefaut[11] @@ -109,7 +102,7 @@ def insereFissureElliptique(geometriesSaines, maillagesSains, \ #allonge = demiGrandAxe/demiPetitAxe #rayonTore = demiPetitAxe/5.0 #generatrice, FaceGenFiss, Pipe_1, FaceFissure, Plane_1, Pipe1Part = self.toreFissure(demiPetitAxe, allonge, rayonTore) - #ellipsoide = self.ellipsoideDefaut(demiPetitAxe, allonge, rayonTore) + #ellipsoide = self.ellipsoideDefaut(demiPetitAxe, allonge) ## --- positionnement sur le bloc defaut de generatrice, tore et plan fissure #if step == 6: @@ -133,7 +126,7 @@ def insereFissureElliptique(geometriesSaines, maillagesSains, \ if step == 7: return None - [ blocPartition, blocp, tore, \ + [ blocPartition, _, tore, \ faceFissure, facesExternes, facesExtBloc, facesExtElli, aretesInternes, ellipsoidep, sharedFaces, sharedEdges, edgesBords] = \ partitionBlocDefaut(extrusionDefaut, facesDefaut, gener1, pipe1, facefis1, ellipsoide1) @@ -145,7 +138,7 @@ def insereFissureElliptique(geometriesSaines, maillagesSains, \ if step == 8: return None - [facetore1, facetore2, volumeTore1, volumeTore2] = facesVolumesToriques(tore, plane1, facesDefaut) + [facetore1, facetore2, _, _] = facesVolumesToriques(tore, plane1, facesDefaut) # --- faces 1/2 circulaires et edges dans le plan de fissure if step == 9: @@ -163,20 +156,20 @@ def insereFissureElliptique(geometriesSaines, maillagesSains, \ if step == 11: return None - [genext, genint, gencnt] = sortGeneratrices(tore, geners) + [_, genint, gencnt] = sortGeneratrices(tore, geners) # --- faces fissure dans et hors tore, et edges face hors tore if step == 12: return None - [facefissintore, facefissoutore, edgeint, edgeext, reverext] = \ + [_, facefissoutore, _, edgeext, reverext] = \ facesFissure(ellipsoidep, faceFissure, extrusionDefaut, genint) # --- identification des faces tore et fissure dans le solide hors tore if step == 13: return None - [blocFaceFiss, blocFaceTore1, blocFaceTore2] = \ + [_, _, _] = \ facesToreInBloc(ellipsoidep, facefissoutore, facetore1, facetore2) # --- identification des shapes modifiées par la duplication des noeuds de la face fissure (d'un coté de la face) @@ -185,14 +178,14 @@ def insereFissureElliptique(geometriesSaines, maillagesSains, \ if step == 14: return None - extrusionFaceFissure, normfiss = shapeSurFissure(plane1) + extrusionFaceFissure, _ = shapeSurFissure(plane1) # --- maillage du bloc partitionne if step == 15: return None - [bloc1, blocComplet] = \ + [_, blocComplet] = \ meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circles, faces, \ gencnt, facefissoutore, edgeext, facesExternes, facesExtBloc, facesExtElli, \ aretesInternes, internalBoundary, ellipsoidep, sharedFaces, sharedEdges, edgesBords, \ diff --git a/src/Tools/blocFissure/gmu/insereFissureGenerale.py b/src/Tools/blocFissure/gmu/insereFissureGenerale.py index e40193ddb..26caa4069 100644 --- a/src/Tools/blocFissure/gmu/insereFissureGenerale.py +++ b/src/Tools/blocFissure/gmu/insereFissureGenerale.py @@ -17,23 +17,23 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # - """procédure complète fissure générale""" import os +import math import logging +from . import initLog + import salome +from salome.smesh import smeshBuilder +import GEOM +import SMESH + from .geomsmesh import geompy from .geomsmesh import geomPublish from .geomsmesh import geomPublishInFather -from . import initLog -import GEOM from .geomsmesh import smesh -from salome.smesh import smeshBuilder -import SMESH -import math -import bisect from .extractionOrientee import extractionOrientee from .extractionOrienteeMulti import extractionOrienteeMulti @@ -54,7 +54,6 @@ from .whichSide import whichSide from .whichSideVertex import whichSideVertex from .projettePointSurCourbe import projettePointSurCourbe from .prolongeWire import prolongeWire -#from getCentreFondFiss import getCentreFondFiss def insereFissureGenerale(maillagesSains, shapesFissure, shapeFissureParams, @@ -106,15 +105,15 @@ def insereFissureGenerale(maillagesSains, #extrusionsDefaut = elementsDefaut[3] dmoyen = elementsDefaut[4] bordsPartages = elementsDefaut[5] - fillconts = elementsDefaut[6] - idFilToCont = elementsDefaut[7] + #fillconts = elementsDefaut[6] + #idFilToCont = elementsDefaut[7] maillageSain = elementsDefaut[8] internalBoundary = elementsDefaut[9] zoneDefaut = elementsDefaut[10] zoneDefaut_skin = elementsDefaut[11] zoneDefaut_internalFaces = elementsDefaut[12] zoneDefaut_internalEdges = elementsDefaut[13] - edgeFondExt = elementsDefaut[14] + #edgeFondExt = elementsDefaut[14] centreFondFiss = elementsDefaut[15] tgtCentre = elementsDefaut[16] @@ -136,7 +135,7 @@ def insereFissureGenerale(maillagesSains, geomPublish(initLog.debug, facesPortFissure, "facesPortFissure") - O, OX, OY, OZ = triedreBase() + O, _, _, _ = triedreBase() # ----------------------------------------------------------------------------- # --- pipe de fond de fissure, prolongé, partition face fissure par pipe @@ -313,16 +312,16 @@ def insereFissureGenerale(maillagesSains, geomPublishInFather(initLog.debug,partitionPeauFissFond, edge, name) dist = [ geompy.MinDistance(pt, edge) for pt in verticesPipePeau] ptPeau = verticesPipePeau[dist.index(min(dist))] # le point de verticesPipePeau a distance minimale de l'edge - [u, PointOnEdge, EdgeInWireIndex] = geompy.MakeProjectionOnWire(ptPeau, wireFondFiss) - logging.debug("u:%s, EdgeInWireIndex: %s, len(edgesFondFiss): %s", u, EdgeInWireIndex, len(edgesFondFiss)) + [parametre, PointOnEdge, EdgeInWireIndex] = geompy.MakeProjectionOnWire(ptPeau, wireFondFiss) + logging.debug("parametre:%s, EdgeInWireIndex: %s, len(edgesFondFiss): %s", parametre, EdgeInWireIndex, len(edgesFondFiss)) localEdgeInFondFiss = edgesFondFiss[EdgeInWireIndex] centre = PointOnEdge - centre2 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, u) + centre2 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, parametre) geomPublishInFather(initLog.debug,partitionPeauFissFond, centre2, "centre2_%d"%iedf) verticesEdgesFondIn.append(centre) name = "verticeEdgesFondIn%d"%iedf geomPublishInFather(initLog.debug,partitionPeauFissFond, centre, name) - norm = geompy.MakeTangentOnCurve(localEdgeInFondFiss, u) + norm = geompy.MakeTangentOnCurve(localEdgeInFondFiss, parametre) geomPublishInFather(initLog.debug,partitionPeauFissFond, centre, "norm%d"%iedf) cercle = geompy.MakeCircle(centre, norm, rayonPipe) geomPublishInFather(initLog.debug,partitionPeauFissFond, cercle, "cerclorig%d"%iedf) @@ -493,8 +492,8 @@ def insereFissureGenerale(maillagesSains, name="partitionPeauByPipe%d"%ifil geomPublish(initLog.debug, partitionPeauByPipe, name) - [edgesPeauFondIn, edgesPeauFondOut, edgesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "EDGE", 1.e-3) - [facesPeauFondIn, facesPeauFondOut, facesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "FACE", 1.e-3) + [edgesPeauFondIn, _, _] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "EDGE", 1.e-3) + [_, _, facesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "FACE", 1.e-3) if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau facesPeauSorted, _, _ = sortFaces(facesPeauFondOn) @@ -659,7 +658,7 @@ def insereFissureGenerale(maillagesSains, edgesPipeFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesPipeFiss)) # edgesFissExtPipe peut ne pas couvrir toute la longueur # edgesPeauFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesFissExtPeau)) # il peut manquer des edges de faceFissureExterne en contact avec la peau dans edgesFissExtPeau - (isDone, closedFreeBoundaries, openFreeBoundaries) = geompy.GetFreeBoundary(faceFissureExterne) + (_, closedFreeBoundaries, _) = geompy.GetFreeBoundary(faceFissureExterne) edgesBordFFE = list() for bound in closedFreeBoundaries: edgesBordFFE += geompy.ExtractShapes(bound, geompy.ShapeType["EDGE"], False) @@ -724,10 +723,10 @@ def insereFissureGenerale(maillagesSains, xyz = meshFondExt.GetNodeXYZ(nodeId) #logging.debug("nodeId %s, coords %s", nodeId, str(xyz)) pt = geompy.MakeVertex(xyz[0], xyz[1], xyz[2]) - u, PointOnEdge, EdgeInWireIndex = geompy.MakeProjectionOnWire(pt, wireFondFiss) # u compris entre 0 et 1 + parametre, PointOnEdge, EdgeInWireIndex = geompy.MakeProjectionOnWire(pt, wireFondFiss) # parametre compris entre 0 et 1 edgeOrder = edgesIdByOrientation[EdgeInWireIndex] - ptGSdic[(edgeOrder, EdgeInWireIndex, u)] = pt - #logging.debug("nodeId %s, u %s", nodeId, str(u)) + ptGSdic[(edgeOrder, EdgeInWireIndex, parametre)] = pt + #logging.debug("nodeId %s, parametre %s", nodeId, str(parametre)) usort = sorted(ptGSdic) logging.debug("nombre de points obtenus par deflexion %s",len(usort)) @@ -735,10 +734,8 @@ def insereFissureGenerale(maillagesSains, origins = list() normals = list() for edu in usort: - ied = edu[1] - u = edu[2] vertcx = ptGSdic[edu] - norm = geompy.MakeTangentOnCurve(edgesFondFiss[ied], u) + norm = geompy.MakeTangentOnCurve(edgesFondFiss[edu[1]], edu[2]) plan = geompy.MakePlane(vertcx, norm, 3*rayonPipe) part = geompy.MakePartition([plan], [wirePipeFiss], list(), list(), geompy.ShapeType["VERTEX"], 0, list(), 0) liste = geompy.ExtractShapes(part, geompy.ShapeType["VERTEX"], True) @@ -912,7 +909,7 @@ def insereFissureGenerale(maillagesSains, vs = geompy.ExtractShapes(obj, geompy.ShapeType["VERTEX"], False) if len(vs) > 2: eds = geompy.ExtractShapes(obj, geompy.ShapeType["EDGE"], False) - [edsorted, minl,maxl] = sortEdges(eds) + [edsorted, _,maxl] = sortEdges(eds) edge = edsorted[-1] else: maxl = geompy.BasicProperties(edge)[0] @@ -932,7 +929,7 @@ def insereFissureGenerale(maillagesSains, logging.debug(" edges issues de la partition: %s", ednouv) for ii, ed in enumerate(ednouv): geomPublish(initLog.debug, ed, "ednouv%d"%ii) - [edsorted, minl,maxl] = sortEdges(ednouv) + [edsorted, _,maxl] = sortEdges(ednouv) logging.debug(" longueur edge trouvée: %s", maxl) edge = edsorted[-1] edges.append(edge) @@ -998,7 +995,7 @@ def insereFissureGenerale(maillagesSains, # --- ajustement precis des points sur edgesPipeFissureExterneC edgesPFE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False) - verticesPFE = findWireIntermediateVertices(wirePipeFissureExterne) # vertices intermédiaires (des points en trop dans ptsInWireFissExtPipe) + verticesPFE, _ = findWireIntermediateVertices(wirePipeFissureExterne) # vertices intermédiaires (des points en trop dans ptsInWireFissExtPipe) idiskmin = idisklim[0] + 1 # on ne prend pas le disque sur la peau, déjà ajusté idiskmax = idisklim[1] # on ne prend pas le disque sur la peau, déjà ajusté idiskint = list() @@ -1166,9 +1163,9 @@ def insereFissureGenerale(maillagesSains, mVols.append(idVols) pipeFissGroup = meshPipe.CreateEmptyGroup( SMESH.VOLUME, 'PIPEFISS' ) - nbAdd = pipeFissGroup.AddFrom( meshPipe.GetMesh() ) + _ = pipeFissGroup.AddFrom( meshPipe.GetMesh() ) - nb, _, new_group = meshPipe.MakeBoundaryElements(SMESH.BND_2DFROM3D, "pipeBoundaries") + _, _, _ = meshPipe.MakeBoundaryElements(SMESH.BND_2DFROM3D, "pipeBoundaries") edgesCircPipeGroup = [edgeCircPipe0Group, edgeCircPipe1Group] # --- fin du maillage du pipe @@ -1176,7 +1173,7 @@ def insereFissureGenerale(maillagesSains, # --- edges de bord, faces défaut à respecter _ = smesh.CreateFilterManager() - nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ]) + _, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ]) criteres = list() unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0) criteres.append(unCritere) @@ -1188,7 +1185,7 @@ def insereFissureGenerale(maillagesSains, # on désigne les faces de peau en quadrangles par le groupe "skinFaces" skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' ) - nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() ) + _ = skinFaces.AddFrom( internalBoundary.GetMesh() ) # --- maillage des éventuelles arêtes vives entre faces reconstruites @@ -1211,7 +1208,7 @@ def insereFissureGenerale(maillagesSains, logging.info(text) raise Exception(text) grpAretesVives = meshAretesVives.CreateEmptyGroup( SMESH.EDGE, 'grpAretesVives' ) - nbAdd = grpAretesVives.AddFrom( meshAretesVives.GetMesh() ) + _ = grpAretesVives.AddFrom( meshAretesVives.GetMesh() ) # ----------------------------------------------------------------------- # --- maillage faces de fissure @@ -1247,9 +1244,9 @@ def insereFissureGenerale(maillagesSains, putName(algo1d, "algo1d_edgeFissPeau") putName(hypo1d, "hypo1d_edgeFissPeau") - grpFaceFissureExterne = meshFaceFiss.GroupOnGeom(faceFissureExterne, "fisOutPi", SMESH.FACE) + _ = meshFaceFiss.GroupOnGeom(faceFissureExterne, "fisOutPi", SMESH.FACE) grpEdgesPeauFissureExterne = meshFaceFiss.GroupOnGeom(edgesPeauFissureExterneC,'edgesPeauFissureExterne',SMESH.EDGE) - grpEdgesPipeFissureExterne = meshFaceFiss.GroupOnGeom(edgesPipeFissureExterneC,'edgesPipeFissureExterne',SMESH.EDGE) + _ = meshFaceFiss.GroupOnGeom(edgesPipeFissureExterneC,'edgesPipeFissureExterne',SMESH.EDGE) is_done = meshFaceFiss.Compute() text = "meshFaceFiss.Compute" @@ -1361,7 +1358,7 @@ def insereFissureGenerale(maillagesSains, raise Exception(text) GroupFaces = meshFacePeau.CreateEmptyGroup( SMESH.FACE, "facePeau%d"%ifil ) - nbAdd = GroupFaces.AddFrom( meshFacePeau.GetMesh() ) + _ = GroupFaces.AddFrom( meshFacePeau.GetMesh() ) meshesFacesPeau.append(meshFacePeau) # --- regroupement des maillages du défaut @@ -1415,7 +1412,7 @@ def insereFissureGenerale(maillagesSains, maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges) putName(maillageSain, nomFicSain+"_coupe") - extrusionFaceFissure, normfiss = shapeSurFissure(facesPortFissure) + _, normfiss = shapeSurFissure(facesPortFissure) maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut, None, None, 'COMPLET', normfiss) @@ -1428,13 +1425,13 @@ def insereFissureGenerale(maillagesSains, logging.info("réorientation face de fissure FACE1") grps = [ grp for grp in groups if grp.GetName() == 'FACE1'] - nb = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1)) + _ = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1)) logging.info("réorientation face de fissure FACE2") plansim = geompy.MakePlane(O, normfiss, 10000) fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim) grps = [ grp for grp in groups if grp.GetName() == 'FACE2'] - nb = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1)) + _ = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1)) _ = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' ) logging.info("export maillage fini") diff --git a/src/Tools/blocFissure/gmu/listOfExtraFunctions.py b/src/Tools/blocFissure/gmu/listOfExtraFunctions.py index 5a0a68811..70a0fdbf1 100644 --- a/src/Tools/blocFissure/gmu/listOfExtraFunctions.py +++ b/src/Tools/blocFissure/gmu/listOfExtraFunctions.py @@ -17,10 +17,9 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Cette fonction permet de scanner la liste de noeuds qui composent le maillage passé en paramètre -""" Created on Mon Jun 23 14:49:36 2014 - @author: I48174 (Olivier HOAREAU) """ @@ -29,189 +28,193 @@ import SMESH from .geomsmesh import smesh def lookForCorner(maillageAScanner): - - """ Cette fonction permet de scanner la liste de noeuds qui composent le - maillage passé en paramètre. On recherche un ou plusieurs coins, ce - qui implique les caractéristiques suivantes: - - le noeud doit appartenir au moins à trois éléments distincts - - chaque élément doit appartenir à un ensemble distinct - La fonction renvoie une liste de coins par l'intermédiaire de l'IDs - chaque noeud. La liste contient en général au maximum deux coins. - """ - - logging.info("start") - - allNodeIds = maillageAScanner.GetNodesId() # On stocke tout les noeuds - listOfCorners = [] - for ND in allNodeIds: - # On parcours la liste de noeuds - listOfElements = maillageAScanner.GetNodeInverseElements(ND) - if len(listOfElements) >=3: - # On teste le nombre d'éléments qui partagent le même noeud - # --- Filtre selon le critère 'coplanar' --- # - listOfCriterion = [smesh.GetCriterion(SMESH.FACE, SMESH.FT_CoplanarFaces, \ - SMESH.FT_Undefined, elem, SMESH.FT_Undefined, SMESH.FT_Undefined, 30) \ - for elem in listOfElements] - listOfFilters = [smesh.GetFilterFromCriteria([criteria]) for criteria in listOfCriterion] - listOfSets = [maillageAScanner.GetIdsFromFilter(filter) for filter in listOfFilters] - if listOfSets.count(listOfSets[0]) == len(listOfSets): - # Si toutes les listes d'éléments sont similaires, on retourne - # au début pour éviter de travailler sur des éléments inutiles. - # Exemple : un noeud appartenant à 4 éléments sur la même face. - continue - for s in listOfSets: - while listOfSets.count(s) > 1: - # On supprime tant que la liste d'éléments n'est pas unique. - listOfSets.remove(s) - if len(listOfSets) >= 3: - # Si on a au moins 3 listes d'élements différentes, on considère - # qu'il y a présence d'un coin. - listOfCorners.append(ND) - return listOfCorners + + """ Cette fonction permet de scanner la liste de noeuds qui composent le + maillage passé en paramètre. On recherche un ou plusieurs coins, ce + qui implique les caractéristiques suivantes: + - le noeud doit appartenir au moins à trois éléments distincts + - chaque élément doit appartenir à un ensemble distinct + La fonction renvoie une liste de coins par l'intermédiaire de l'IDs + chaque noeud. La liste contient en général au maximum deux coins. + """ + + logging.info("start") + + allNodeIds = maillageAScanner.GetNodesId() # On stocke tout les noeuds + listOfCorners = list() + for noeud in allNodeIds: + # On parcours la liste de noeuds + listOfElements = maillageAScanner.GetNodeInverseElements(noeud) + if len(listOfElements) >=3: + # On teste le nombre d'éléments qui partagent le même noeud + # --- Filtre selon le critère 'coplanar' --- # + listOfCriterion = [smesh.GetCriterion(SMESH.FACE, SMESH.FT_CoplanarFaces, \ + SMESH.FT_Undefined, elem, SMESH.FT_Undefined, SMESH.FT_Undefined, 30) \ + for elem in listOfElements] + listOfFilters = [smesh.GetFilterFromCriteria([criteria]) for criteria in listOfCriterion] + listOfSets = [maillageAScanner.GetIdsFromFilter(filtre) for filtre in listOfFilters] + if listOfSets.count(listOfSets[0]) == len(listOfSets): + # Si toutes les listes d'éléments sont similaires, on retourne + # au début pour éviter de travailler sur des éléments inutiles. + # Exemple : un noeud appartenant à 4 éléments sur la même face. + continue + for l_aux in listOfSets: + while listOfSets.count(l_aux) > 1: + # On supprime tant que la liste d'éléments n'est pas unique. + listOfSets.remove(l_aux) + if len(listOfSets) >= 3: + # Si on a au moins 3 listes d'élements différentes, on considère + # qu'il y a présence d'un coin. + listOfCorners.append(noeud) + + return listOfCorners def createLinesFromMesh(maillageSupport): - - """ Cette fonction permet de générer une liste de lignes à partir du - maillage support passé en paramètre. On démarre à partir d'un coin - simple et on parcourt tout les noeuds pour former une ligne. Soit la - figure ci-dessous : - - 1_____4_____7 On part du coin N1, et on cherche les noeuds - | | | successifs tels que [1, 2, 3]. Lorsqu'on arrive - | 1 | 3 | arrive sur le noeud de fin de ligne N3, on repart - | | | du noeud précédent du premier élément (E1), à - 2_____5_____8 savoir le noeud N4. On suit les noeuds succesifs - | | | [4, 5, 6] comme précédemment et ainsi de suite. - | 2 | 4 | Lorsqu'on arrive sur le dernier noeud de la - | | | dernière ligne, à savoir le noeud N9, on considère - 3_____6_____9 que toutes les lignes sont créées. - - La fonction retourne une liste de lignes utilisées par la suite. - """ - - logging.info("start") - - allNodeIds = maillageSupport.GetNodesId() - while len(allNodeIds): - nodeIds = allNodeIds - for idNode in nodeIds: # rechercher un coin - elems = maillageSupport.GetNodeInverseElements(idNode) - if len(elems) == 1: - # un coin: un noeud, un element quadrangle - elem = elems[0] - break; - idStart = idNode # le noeud de coin - elemStart = elem # l'élément quadrangle au coin - xyz = maillageSupport.GetNodeXYZ(idStart) - logging.debug("idStart %s, coords %s", idStart, str(xyz)) - - nodelines =[] # on va constituer une liste de lignes de points - nextLine = True - ligneFinale = False - while nextLine: - logging.debug("--- une ligne") - idNode = idStart - elem = elemStart - if ligneFinale: - agauche = False # sens de parcours des 4 noeuds d'un quadrangle - nextLine = False + + """ Cette fonction permet de générer une liste de lignes à partir du + maillage support passé en paramètre. On démarre à partir d'un coin + simple et on parcourt tout les noeuds pour former une ligne. Soit la + figure ci-dessous : + + 1_____4_____7 On part du coin N1, et on cherche les noeuds + | | | successifs tels que [1, 2, 3]. Lorsqu'on arrive + | 1 | 3 | arrive sur le noeud de fin de ligne N3, on repart + | | | du noeud précédent du premier élément (E1), à + 2_____5_____8 savoir le noeud N4. On suit les noeuds succesifs + | | | [4, 5, 6] comme précédemment et ainsi de suite. + | 2 | 4 | Lorsqu'on arrive sur le dernier noeud de la + | | | dernière ligne, à savoir le noeud N9, on considère + 3_____6_____9 que toutes les lignes sont créées. + + La fonction retourne une liste de lignes utilisées par la suite. + """ + + logging.info("start") + + allNodeIds = maillageSupport.GetNodesId() + while len(allNodeIds): + nodeIds = allNodeIds + for idNode in nodeIds: # rechercher un coin + elems = maillageSupport.GetNodeInverseElements(idNode) + if len(elems) == 1: + # un coin: un noeud, un element quadrangle + elem = elems[0] + idNode_c = idNode + break + idStart = idNode_c # le noeud de coin + elemStart = elem # l'élément quadrangle au coin + xyz = maillageSupport.GetNodeXYZ(idStart) + logging.debug("idStart %s, coords %s", idStart, str(xyz)) + + nodelines = list() # on va constituer une liste de lignes de points + nextLine = True + ligneFinale = False + while nextLine: + logging.debug("--- une ligne") + idNode = idStart + elem = elemStart + if ligneFinale: + agauche = False # sens de parcours des 4 noeuds d'un quadrangle + nextLine = False + else: + agauche = True + ligneIncomplete = True # on commence une ligne de points + debutLigne = True + nodeline = list() + elemline = list() + while ligneIncomplete: # compléter la ligne de points + nodeline.append(idNode) + allNodeIds.remove(idNode) + elemline.append(elem) + nodes = maillageSupport.GetElemNodes(elem) + i_aux = nodes.index(idNode) # repérer l'index du noeud courant (i_aux) dans l'élément quadrangle (0 a 3) + if agauche: # déterminer le noeud suivant (j_aux) et celui opposé (k_aux) dans le quadrangle + if i_aux < 3: + j_aux = i_aux+1 + else: + j_aux = 0 + if j_aux < 3: + k_aux = j_aux+1 + else: + k_aux = 0 + else: + if i_aux > 0: + j_aux = i_aux -1 + else: + j_aux = 3 + if j_aux > 0: + k_aux = j_aux -1 + else: + k_aux = 3 + isuiv = nodes[j_aux] # noeud suivant + iapres = nodes[k_aux] # noeud opposé + if debutLigne: + debutLigne = False + # précédent a trouver, dernière ligne : précédent au lieu de suivant + if agauche: + if i_aux > 0: + iprec = nodes[i_aux -1] + else: + iprec = nodes[3] + idStart = iprec + elems3 = maillageSupport.GetNodeInverseElements(iprec) + if len(elems3) == 1: # autre coin + ligneFinale = True else: - agauche = True - ligneIncomplete = True # on commence une ligne de points - debutLigne = True - nodeline = [] - elemline = [] - while ligneIncomplete: # compléter la ligne de points - nodeline.append(idNode) - allNodeIds.remove(idNode) - elemline.append(elem) - nodes = maillageSupport.GetElemNodes(elem) - i = nodes.index(idNode) # repérer l'index du noeud courant (i) dans l'élément quadrangle (0 a 3) - if agauche: # déterminer le noeud suivant (j) et celui opposé (k) dans le quadrangle - if i < 3: - j = i+1 - else: - j = 0 - if j < 3: - k = j+1 - else: - k = 0 - else: - if i > 0: - j = i -1 - else: - j = 3 - if j > 0: - k = j -1 - else: - k = 3 - isuiv = nodes[j] # noeud suivant - iapres = nodes[k] # noeud opposé - if debutLigne: - debutLigne = False - # précédent a trouver, dernière ligne : précédent au lieu de suivant - if agauche: - if i > 0: - iprec = nodes[i -1] - else: - iprec = nodes[3] - idStart = iprec - elems3 = maillageSupport.GetNodeInverseElements(iprec) - if len(elems3) == 1: # autre coin - ligneFinale = True - else: - for elem3 in elems3: - if elem3 != elem: - elemStart = elem3 - break - #print nodes, idNode, isuiv, iapres - elems1 = maillageSupport.GetNodeInverseElements(isuiv) - elems2 = maillageSupport.GetNodeInverseElements(iapres) - ligneIncomplete = False - for elem2 in elems2: - if elems1.count(elem2) and elem2 != elem: - ligneIncomplete = True - idNode = isuiv - elem = elem2 - break - if not ligneIncomplete: - nodeline.append(isuiv) - allNodeIds.remove(isuiv) - logging.debug("nodeline %s", nodeline) - logging.debug("elemline %s", elemline) - nodelines.append(nodeline) - - # on a constitué une liste de lignes de points connexes - logging.debug("dimensions [%s, %s]", len(nodelines), len(nodeline)) - - return nodelines + for elem3 in elems3: + if elem3 != elem: + elemStart = elem3 + break + + #print nodes, idNode, isuiv, iapres + elems1 = maillageSupport.GetNodeInverseElements(isuiv) + elems2 = maillageSupport.GetNodeInverseElements(iapres) + ligneIncomplete = False + for elem2 in elems2: + if elems1.count(elem2) and elem2 != elem: + ligneIncomplete = True + idNode = isuiv + elem = elem2 + break + if not ligneIncomplete: + nodeline.append(isuiv) + allNodeIds.remove(isuiv) + logging.debug("nodeline %s", nodeline) + logging.debug("elemline %s", elemline) + nodelines.append(nodeline) + + # on a constitué une liste de lignes de points connexes + logging.debug("dimensions [%s, %s]", len(nodelines), len(nodeline)) + + return nodelines def createNewMeshesFromCorner(maillageSupport, listOfCorners): - - """ Cette fonction permet de générer un nouveau maillage plus facile à - utiliser. On démarre d'un coin et on récupère les trois éléments - auquel le noeud appartient. Grâce à un filtre 'coplanar' sur les trois - éléments, on peut générer des faces distinctes. - """ - - logging.info("start") - - tmp = [] - listOfNewMeshes = [] - for corner in listOfCorners: - elems = maillageSupport.GetNodeInverseElements(corner) - for i, elem in enumerate(elems): - # --- Filtre selon le critère 'coplanar' --- # - critere = smesh.GetCriterion(SMESH.FACE, SMESH.FT_CoplanarFaces, \ - SMESH.FT_Undefined, elem, SMESH.FT_Undefined, SMESH.FT_Undefined, 30) - filtre = smesh.GetFilterFromCriteria([critere]) - grp = maillageSupport.GroupOnFilter(SMESH.FACE, 'grp', filtre) - # On copie le maillage en fonction du filtre - msh = smesh.CopyMesh(grp, 'new_{0}'.format(i + 1), False, True) - # On stocke l'ensemble des noeuds du maillage dans tmp - # On ajoute le maillage à la liste des nouveaux maillages - # seulement s'il n'y est pas déjà - tmp.append(msh.GetNodesId()) - if tmp.count(msh.GetNodesId()) <= 1: - listOfNewMeshes.append(msh) - return listOfNewMeshes \ No newline at end of file + + """ Cette fonction permet de générer un nouveau maillage plus facile à + utiliser. On démarre d'un coin et on récupère les trois éléments + auquel le noeud appartient. Grâce à un filtre 'coplanar' sur les trois + éléments, on peut générer des faces distinctes. + """ + + logging.info("start") + + tmp = list() + listOfNewMeshes = list() + for corner in listOfCorners: + elems = maillageSupport.GetNodeInverseElements(corner) + for i_aux, elem in enumerate(elems): + # --- Filtre selon le critère 'coplanar' --- # + critere = smesh.GetCriterion(SMESH.FACE, SMESH.FT_CoplanarFaces, \ + SMESH.FT_Undefined, elem, SMESH.FT_Undefined, SMESH.FT_Undefined, 30) + filtre = smesh.GetFilterFromCriteria([critere]) + grp = maillageSupport.GroupOnFilter(SMESH.FACE, 'grp', filtre) + # On copie le maillage en fonction du filtre + msh = smesh.CopyMesh(grp, 'new_{0}'.format(i_aux+1), False, True) + # On stocke l'ensemble des noeuds du maillage dans tmp + # On ajoute le maillage à la liste des nouveaux maillages + # seulement s'il n'y est pas déjà + tmp.append(msh.GetNodesId()) + if ( tmp.count(msh.GetNodesId()) <= 1 ): + listOfNewMeshes.append(msh) + + return listOfNewMeshes diff --git a/src/Tools/blocFissure/gmu/mailleAretesEtJonction.py b/src/Tools/blocFissure/gmu/mailleAretesEtJonction.py index 55e52f134..b39f899aa 100644 --- a/src/Tools/blocFissure/gmu/mailleAretesEtJonction.py +++ b/src/Tools/blocFissure/gmu/mailleAretesEtJonction.py @@ -17,24 +17,24 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""edges de bord, faces défaut à respecter""" import logging +import SMESH + from .geomsmesh import geompy from .geomsmesh import smesh -import SMESH from .putName import putName def mailleAretesEtJonction(internalBoundary, aretesVivesCoupees, lgAretesVives): - """ - edges de bord, faces défaut à respecter - """ + """edges de bord, faces défaut à respecter""" logging.info('start') - aFilterManager = smesh.CreateFilterManager() - nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ]) - criteres = [] + _ = smesh.CreateFilterManager() + _, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ]) + criteres = list() unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0) criteres.append(unCritere) filtre = smesh.GetFilterFromCriteria(criteres) @@ -45,7 +45,7 @@ def mailleAretesEtJonction(internalBoundary, aretesVivesCoupees, lgAretesVives): # on désigne les faces de peau en quadrangles par le groupe "skinFaces" skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' ) - nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() ) + _ = skinFaces.AddFrom( internalBoundary.GetMesh() ) # --- maillage des éventuelles arêtes vives entre faces reconstruites @@ -70,6 +70,6 @@ def mailleAretesEtJonction(internalBoundary, aretesVivesCoupees, lgAretesVives): raise Exception(text) grpAretesVives = meshAretesVives.CreateEmptyGroup( SMESH.EDGE, 'grpAretesVives' ) - nbAdd = grpAretesVives.AddFrom( meshAretesVives.GetMesh() ) + _ = grpAretesVives.AddFrom( meshAretesVives.GetMesh() ) return (internalBoundary, bordsLibres, grpAretesVives) diff --git a/src/Tools/blocFissure/gmu/mailleFacesFissure.py b/src/Tools/blocFissure/gmu/mailleFacesFissure.py index d18bd115f..605b0752b 100644 --- a/src/Tools/blocFissure/gmu/mailleFacesFissure.py +++ b/src/Tools/blocFissure/gmu/mailleFacesFissure.py @@ -17,13 +17,14 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""maillage faces de fissure""" import logging -from .geomsmesh import geompy -from .geomsmesh import smesh -from salome.smesh import smeshBuilder import SMESH +from salome.smesh import smeshBuilder + +from .geomsmesh import smesh from .putName import putName diff --git a/src/Tools/blocFissure/gmu/mailleFacesPeau.py b/src/Tools/blocFissure/gmu/mailleFacesPeau.py index 0839e3573..5566ccac2 100644 --- a/src/Tools/blocFissure/gmu/mailleFacesPeau.py +++ b/src/Tools/blocFissure/gmu/mailleFacesPeau.py @@ -22,13 +22,14 @@ import logging +import SMESH +from salome.smesh import smeshBuilder + from .geomsmesh import geompy -from .geomsmesh import geomPublish from .geomsmesh import geomPublishInFather -from . import initLog from .geomsmesh import smesh -from salome.smesh import smeshBuilder -import SMESH + +from . import initLog from .putName import putName @@ -41,7 +42,7 @@ def mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut, \ logging.info('start') logging.info(mailleur+" pour le cas n° %d"%nro_cas) nbFacesFilling = len(partitionsPeauFissFond) - boutFromIfil = [None for i in range(nbFacesFilling)] + boutFromIfil = [None for _ in range(nbFacesFilling)] if idFillingFromBout[0] != idFillingFromBout[1]: # repérage des extremites du pipe quand elles débouchent sur des faces différentes boutFromIfil[idFillingFromBout[0]] = 0 boutFromIfil[idFillingFromBout[1]] = 1 @@ -102,15 +103,16 @@ def mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut, \ putName(algo1d, "algo1d_bordsVifs", ifil, nro_cas) putName(hypo1d, "hypo1d_bordsVifs", ifil, nro_cas) - for i, edgeCirc in enumerate(edgesCircPeau): - logging.info("i = {}".format(i)) + for i_aux, edgeCirc in enumerate(edgesCircPeau): + texte = "i_aux = {}".format(i_aux) + logging.info(texte) if edgeCirc is not None: algo1d = meshFacePeau.UseExisting1DElements(geom=edgeCirc) # addToStudy() failed ? if boutFromIfil[ifil] is None: - hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[i] ],0,0) + hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[i_aux] ],0,0) else: hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[boutFromIfil[ifil]] ],0,0) - name = "cercle%d"%i + name = "cercle{}".format(i_aux) putName(algo1d.GetSubMesh(), name, ifil, nro_cas) putName(algo1d, "algo1d_" + name, ifil, nro_cas) putName(hypo1d, "hypo1d_" + name, ifil, nro_cas) diff --git a/src/Tools/blocFissure/gmu/meshBlocPart.py b/src/Tools/blocFissure/gmu/meshBlocPart.py index 688c18d07..4693f307f 100644 --- a/src/Tools/blocFissure/gmu/meshBlocPart.py +++ b/src/Tools/blocFissure/gmu/meshBlocPart.py @@ -17,33 +17,33 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Maillage du bloc partitionné""" import logging -from .geomsmesh import geompy -from .geomsmesh import smesh -from salome.smesh import smeshBuilder + import SMESH +from salome.smesh import smeshBuilder from salome.StdMeshers import StdMeshersBuilder + +from .geomsmesh import geompy +from .geomsmesh import smesh + from .putName import putName # ----------------------------------------------------------------------------- -# --- maillage du bloc partitionne def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circles, faces, \ gencnt, facefissoutore, edgeext, facesExternes, facesExtBloc, facesExtElli, \ aretesInternes, internalBoundary, ellipsoidep, sharedFaces, sharedEdges, edgesBords, \ nbsegExt, nbsegGen, nbsegRad, scaleRad, reverses, reverext, nbsegCercle, nbsegFis, dmoyen, lensegEllipsoide, \ mailleur="MeshGems"): - """Maillage du bloc partitionné - - TODO: a completer - """ + """Maillage du bloc partitionné""" logging.info('start') # --- edges de bord à respecter - aFilterManager = smesh.CreateFilterManager() - nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ]) + _ = smesh.CreateFilterManager() + _, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ]) criteres = list() unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0) criteres.append(unCritere) @@ -55,22 +55,22 @@ def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circle bloc1 = smesh.Mesh(blocPartition) - for i, sharedFaces_i in enumerate(sharedFaces): + for i_aux, sharedFaces_i in enumerate(sharedFaces): algo2d = bloc1.Triangle(algo=smeshBuilder.NETGEN, geom=sharedFaces_i) hypo2d = algo2d.Parameters(which=smesh.SIMPLE) hypo2d.SetLocalLength(lensegEllipsoide) hypo2d.LengthFromEdges() hypo2d.SetAllowQuadrangles(0) - putName(algo2d.GetSubMesh(), "sharedFaces", i) - putName(algo2d, "algo2d_sharedFaces", i) - putName(hypo2d, "hypo2d_sharedFaces", i) + putName(algo2d.GetSubMesh(), "sharedFaces", i_aux) + putName(algo2d, "algo2d_sharedFaces", i_aux) + putName(hypo2d, "hypo2d_sharedFaces", i_aux) - for i, sharedEdges_i in enumerate(sharedEdges): + for i_aux, sharedEdges_i in enumerate(sharedEdges): algo1d = bloc1.Segment(geom=sharedEdges_i) hypo1d = algo1d.LocalLength(lensegEllipsoide) - putName(algo1d.GetSubMesh(), "sharedEdges", i) - putName(algo1d, "algo1d_sharedEdges", i) - putName(hypo1d, "hypo1d_sharedEdges", i) + putName(algo1d.GetSubMesh(), "sharedEdges", i_aux) + putName(algo1d, "algo1d_sharedEdges", i_aux) + putName(hypo1d, "hypo1d_sharedEdges", i_aux) declareAlgoEllipsoideFirst = False if declareAlgoEllipsoideFirst: @@ -90,32 +90,32 @@ def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circle putName(algo1d, "algo1d_tore") putName(hypo1d, "hypo1d_tore") - for i, faces_i in enumerate(faces): + for i_aux, faces_i in enumerate(faces): algo2d = bloc1.Quadrangle(geom=faces_i) hypo2d = smesh.CreateHypothesis('QuadrangleParams') - hypo2d.SetTriaVertex( geompy.GetSubShapeID(blocPartition,centres[i]) ) + hypo2d.SetTriaVertex( geompy.GetSubShapeID(blocPartition,centres[i_aux]) ) hypo2d.SetQuadType( StdMeshersBuilder.QUAD_STANDARD ) - status = bloc1.AddHypothesis(hypo2d,faces_i) - putName(algo2d.GetSubMesh(), "faces", i) - putName(algo2d, "algo2d_faces", i) - putName(hypo2d, "hypo2d_faces", i) + _ = bloc1.AddHypothesis(hypo2d,faces_i) + putName(algo2d.GetSubMesh(), "faces", i_aux) + putName(algo2d, "algo2d_faces", i_aux) + putName(hypo2d, "hypo2d_faces", i_aux) - for i, edges_i in enumerate(edges): + for i_aux, edges_i in enumerate(edges): algo1d = bloc1.Segment(geom=edges_i) - if reverses[i] > 0: + if reverses[i_aux] > 0: hypo1d = algo1d.NumberOfSegments(nbsegRad, scaleRad,[ geompy.GetSubShapeID(blocPartition,edges_i) ]) else: - hypo1d = algo1d.NumberOfSegments(nbsegRad, scaleRad,[ ]) - putName(algo1d.GetSubMesh(), "edges", i) - putName(algo1d, "algo1d_edges", i) - putName(hypo1d, "hypo1d_edges", i) + hypo1d = algo1d.NumberOfSegments(nbsegRad, scaleRad,[ ]) + putName(algo1d.GetSubMesh(), "edges", i_aux) + putName(algo1d, "algo1d_edges", i_aux) + putName(hypo1d, "hypo1d_edges", i_aux) - for i, circles_i in enumerate(circles): + for i_aux, circles_i in enumerate(circles): algo1d = bloc1.Segment(geom=circles_i) hypo1d = algo1d.NumberOfSegments(nbsegCercle) - putName(algo1d.GetSubMesh(), "circles", i) - putName(algo1d, "algo1d_circles", i) - putName(hypo1d, "hypo1d_circles", i) + putName(algo1d.GetSubMesh(), "circles", i_aux) + putName(algo1d, "algo1d_circles", i_aux) + putName(hypo1d, "hypo1d_circles", i_aux) if len(edgeext) == 1: densite = int(round(nbsegFis/2)) @@ -130,24 +130,23 @@ def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circle else: longTotal = 0 longEdgeExts = list() - for i, edgeext_i in enumerate(edgeext): + for edgeext_i in edgeext: props = geompy.BasicProperties(edgeext_i) longEdgeExts.append(props[0]) longTotal += props[0] - for i, edgeext_i in enumerate(edgeext): - local = longTotal/nbsegFis - nbLocal = int(round(nbsegFis*longEdgeExts[i]/longTotal)) + for i_aux, edgeext_i in enumerate(edgeext): + nbLocal = int(round(nbsegFis*longEdgeExts[i_aux]/longTotal)) densite = int(round(nbLocal/2)) algo1d = bloc1.Segment(geom=edgeext_i) hypo1d = algo1d.NumberOfSegments(nbLocal) hypo1d.SetDistrType( 2 ) hypo1d.SetConversionMode( 1 ) hypo1d.SetTableFunction( [ 0, densite, 0.8, 1, 1, 1 ] ) - if reverext[i]: + if reverext[i_aux]: hypo1d.SetReversedEdges([ geompy.GetSubShapeID(blocPartition, edgeext_i) ]) - putName(algo1d.GetSubMesh(), "edgeext", i) - putName(algo1d, "algo1d_edgeext", i) - putName(hypo1d, "hypo1d_edgeext", i) + putName(algo1d.GetSubMesh(), "edgeext", i_aux) + putName(algo1d, "algo1d_edgeext", i_aux) + putName(hypo1d, "hypo1d_edgeext", i_aux) algo2d = bloc1.Triangle(algo=smeshBuilder.NETGEN_2D, geom=facefissoutore) hypo2d = algo2d.LengthFromEdges() @@ -159,25 +158,25 @@ def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circle maxElemArea = 0.5*dmoyen*dmoyen logging.debug("dmoyen %s, maxElemArea %s", dmoyen, maxElemArea) - for i, facesExternes_i in enumerate(facesExternes): + for i_aux, facesExternes_i in enumerate(facesExternes): algo2d = bloc1.Triangle(algo=smeshBuilder.NETGEN_2D, geom=facesExternes_i) hypo2d = algo2d.MaxElementArea(maxElemArea) if edgesBords is None: algo1d = bloc1.Segment(geom=facesExternes_i) hypo1d = algo1d.NumberOfSegments(1) - putName(algo2d.GetSubMesh(), "facesExternes", i) - putName(algo2d, "algo2d_facesExternes", i) - putName(hypo2d, "hypo2d_facesExternes", i) + putName(algo2d.GetSubMesh(), "facesExternes", i_aux) + putName(algo2d, "algo2d_facesExternes", i_aux) + putName(hypo2d, "hypo2d_facesExternes", i_aux) if edgesBords is None: - putName(algo1d, "algo1d_facesExternes", i) - putName(hypo1d, "hypo1d_facesExternes", i) + putName(algo1d, "algo1d_facesExternes", i_aux) + putName(hypo1d, "hypo1d_facesExternes", i_aux) - for i, aretesInternes_i in enumerate(aretesInternes): + for i_aux, aretesInternes_i in enumerate(aretesInternes): algo1d = bloc1.Segment(geom=aretesInternes_i) hypo1d = algo1d.NumberOfSegments(nbsegExt) - putName(algo1d.GetSubMesh(), "aretesInternes", i) - putName(algo1d, "algo1d_aretesInternes", i) - putName(hypo1d, "hypo1d_aretesInternes", i) + putName(algo1d.GetSubMesh(), "aretesInternes", i_aux) + putName(algo1d, "algo1d_aretesInternes", i_aux) + putName(hypo1d, "hypo1d_aretesInternes", i_aux) if edgesBords is not None: algo1d = bloc1.UseExisting1DElements(geom=edgesBords) @@ -193,16 +192,16 @@ def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circle putName(algo3d, "algo3d_ellipsoide") putName(hypo3d, "hypo3d_ellipsoide") - faceFissure1 = bloc1.GroupOnGeom(faceFissure,'FACE1',SMESH.FACE) - noeudsFondFissure = bloc1.GroupOnGeom(gencnt,'nfondfis',SMESH.NODE) + _ = bloc1.GroupOnGeom(faceFissure,'FACE1',SMESH.FACE) + _ = bloc1.GroupOnGeom(gencnt,'nfondfis',SMESH.NODE) groups_faceCommuneEllipsoideBloc = list() - for i, sharedFaces_i in enumerate(sharedFaces): - name = "faceCommuneEllipsoideBloc_%d"%i + for i_aux, sharedFaces_i in enumerate(sharedFaces): + name = "faceCommuneEllipsoideBloc_{}".format(i_aux) groups_faceCommuneEllipsoideBloc.append(bloc1.GroupOnGeom(sharedFaces_i, name, SMESH.FACE)) groups_faceExterneBloc = list() - for i, facesExtBloc_i in enumerate(facesExtBloc): - name = "faceExterneBloc_%d"%i + for i_aux, facesExtBloc_i in enumerate(facesExtBloc): + name = "faceExterneBloc_{}".format(i_aux) groups_faceExterneBloc.append(bloc1.GroupOnGeom(facesExtBloc_i, name, SMESH.FACE)) is_done = bloc1.Compute() @@ -214,18 +213,18 @@ def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circle logging.info(text) raise Exception(text) - nbRemoved = bloc1.RemoveOrphanNodes() + _ = bloc1.RemoveOrphanNodes() skinBlocMeshes = list() - for i, groups_faceCommuneEllipsoideBloc_i in enumerate(groups_faceCommuneEllipsoideBloc): - name = "faceCommuneEllipsoideBloc_%d"%i + for i_aux, groups_faceCommuneEllipsoideBloc_i in enumerate(groups_faceCommuneEllipsoideBloc): + name = "faceCommuneEllipsoideBloc_{}".format(i_aux) skinBlocMeshes.append(smesh.CopyMesh(groups_faceCommuneEllipsoideBloc_i, name, 0, 0)) - for i, groups_faceExterneBloc_i in enumerate(groups_faceExterneBloc): - name = "faceExterneBloc_%d"%i + for i_aux, groups_faceExterneBloc_i in enumerate(groups_faceExterneBloc): + name = "faceExterneBloc_{}".format(i_aux) skinBlocMeshes.append(smesh.CopyMesh(groups_faceExterneBloc_i, name, 0, 0)) meshesBloc = [internalBoundary.GetMesh()] - for i, skinBlocMeshes_i in enumerate(skinBlocMeshes): + for skinBlocMeshes_i in skinBlocMeshes: meshesBloc.append(skinBlocMeshes_i.GetMesh()) blocMesh = smesh.Concatenate(meshesBloc, 1, 1, 1e-05,False) diff --git a/src/Tools/blocFissure/gmu/orderEdgesFromWire.py b/src/Tools/blocFissure/gmu/orderEdgesFromWire.py index 83228cdc0..112cb2f03 100644 --- a/src/Tools/blocFissure/gmu/orderEdgesFromWire.py +++ b/src/Tools/blocFissure/gmu/orderEdgesFromWire.py @@ -17,64 +17,61 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Trouver les vertices intermédiaires d'un wire""" import logging -from .geomsmesh import geompy -# ----------------------------------------------------------------------------- -# --- trouver les vertices intermediaires d'un wire +from .geomsmesh import geompy def orderEdgesFromWire(aWire): - """ - fournit les edges ordonnées d'un wire selon ExtractShapes(,,False), + """Fournit les edges ordonnées d'un wire selon ExtractShapes(,,False), et l'ordre des edges selon le sens de parcours (ordre des indices de la liste d'edges) """ logging.info("start") edges = geompy.ExtractShapes(aWire, geompy.ShapeType["EDGE"], False) - + idverts = dict() - for i, edge in enumerate(edges): + for i_aux, edge in enumerate(edges): verts = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], True) -# idverts[(i,0)] = verts[0] -# idverts[(i,1)] = verts[1] - v0 = geompy.MakeVertexOnCurve(edge, 0.0) - dist = geompy.MinDistance(v0, verts[0]) + vertex_a = geompy.MakeVertexOnCurve(edge, 0.0) + dist = geompy.MinDistance(vertex_a, verts[0]) if dist < 1.e-4: - idverts[(i,0)] = verts[0] - idverts[(i,1)] = verts[1] + idverts[(i_aux,0)] = verts[0] + idverts[(i_aux,1)] = verts[1] else: - idverts[(i,0)] = verts[1] - idverts[(i,1)] = verts[0] - + idverts[(i_aux,0)] = verts[1] + idverts[(i_aux,1)] = verts[0] + idsubs = dict() - for kv, sub in idverts.items(): + for i_aux, sub in idverts.items(): subid = geompy.GetSubShapeID(aWire, sub) - if subid in list(idsubs.keys()): - idsubs[subid].append(kv) + if ( subid in idsubs ): + idsubs[subid].append(i_aux) else: - idsubs[subid] = [kv] - + idsubs[subid] = [i_aux] + debut = -1 - fin = -1 - for k, kvs in idsubs.items(): + fin = -1 + for _, kvs in idsubs.items(): if len(kvs) == 1: # une extremité - kv = kvs[0] - if kv[1] == 0: - debut = kv[0] + kv0 = kvs[0] + if kv0[1] == 0: + debut = kv0[0] else: - fin = kv[0] - logging.debug("nombre d'edges: {}, indice edge début: {}, fin: {}".format(len(edges), debut, fin)) + fin = kv0[0] + texte = "nombre d'edges: {}, indice edge début: {}, fin: {}".format(len(edges), debut, fin) + logging.debug(texte) if debut < 0: logging.critical("les edges du wire ne sont pas orientées dans le même sens: pas de début trouvé") return edges, list(range(len(edges))) - + orderedList = [debut] while len(orderedList) < len(edges): bout = orderedList[-1] vertex = idverts[(bout,1)] - for k, v in idverts.items(): + for k, vertex_a in idverts.items(): if k[0] not in orderedList: - if geompy.MinDistance(vertex, v) < 1.e-4: + if geompy.MinDistance(vertex, vertex_a) < 1.e-4: if k[1] == 0: orderedList.append(k[0]) break @@ -82,9 +79,12 @@ def orderEdgesFromWire(aWire): logging.critical("les edges du wire ne sont pas orientées dans le même sens: une edge à l'envers") return edges, list(range(len(edges))) - logging.debug("liste des edges ordonnées selon le sens de parcours : {}".format(orderedList)) + texte = "liste des edges ordonnées selon le sens de parcours : {}".format(orderedList) + logging.debug(texte) accessList = list(range(len(orderedList))) - for i,k in enumerate(orderedList): - accessList[k] = i - logging.info("position ordonnée des edges selon le sens de parcours : {}".format(accessList)) + for i_aux,k_aux in enumerate(orderedList): + accessList[k_aux] = i_aux + texte = "position ordonnée des edges selon le sens de parcours : {}".format(accessList) + logging.info(texte) + return edges, accessList diff --git a/src/Tools/blocFissure/gmu/partitionBlocDefaut.py b/src/Tools/blocFissure/gmu/partitionBlocDefaut.py index d38f8e55a..6c59c713a 100644 --- a/src/Tools/blocFissure/gmu/partitionBlocDefaut.py +++ b/src/Tools/blocFissure/gmu/partitionBlocDefaut.py @@ -17,15 +17,17 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Partition du bloc defaut par generatrice, tore et plan fissure""" import logging + +import GEOM + from .geomsmesh import geompy from .geomsmesh import geomPublish from .geomsmesh import geomPublishInFather -from . import initLog -# ----------------------------------------------------------------------------- -# --- partition du bloc defaut par generatrice, tore et plan fissure +from . import initLog def partitionBlocDefaut(volDefaut, facesDefaut, gener, pipe, facefis, ellipsoide): @@ -56,9 +58,9 @@ def partitionBlocDefaut(volDefaut, facesDefaut, gener, pipe, #geomPublishInFather(initLog.debug, volDefautPart, gencnt, 'generatrice' ) solids = geompy.ExtractShapes(blocp, geompy.ShapeType["SOLID"], True) - vols = [] - for i in range(len(solids)): - props = geompy.BasicProperties(solids[i]) + vols = list() + for solid in solids: + props = geompy.BasicProperties(solid) vols.append(props[2]) maxvol = max(vols) imaxvol = vols.index(maxvol) @@ -72,110 +74,111 @@ def partitionBlocDefaut(volDefaut, facesDefaut, gener, pipe, geomPublishInFather(initLog.debug, volDefautPart, ellipsoidep, 'ellipsoide' ) sharedFaces = geompy.GetSharedShapesMulti([blocp, ellipsoidep], geompy.ShapeType["FACE"]) - for i in range(len(sharedFaces)): - name = "faceCommuneEllipsoideBloc_%d"%i - geomPublishInFather(initLog.debug,blocp, sharedFaces[i], name) + for i_aux, face in enumerate(sharedFaces): + name = "faceCommuneEllipsoideBloc_{}".format(i_aux) + geomPublishInFather(initLog.debug,blocp, face, name) #sharedEdges = geompy.GetSharedShapesMulti([blocp, ellipsoidep], geompy.ShapeType["EDGE"]) allSharedEdges = geompy.GetSharedShapesMulti([blocp, ellipsoidep], geompy.ShapeType["EDGE"]) - sharedEdges = [] - for i in range(len(allSharedEdges)): - if geompy.NbShapes(allSharedEdges[i], geompy.ShapeType["VERTEX"]) > 1: # edge non degeneree - sharedEdges.append(allSharedEdges[i]) - for i in range(len(sharedEdges)): - name = "edgeCommuneEllipsoideBloc_%d"%i - geomPublishInFather(initLog.debug,blocp, sharedEdges[i], name) - - facesExternes = [] - facesExtBloc = [] - facesExtElli = [] + sharedEdges = list() + for face in allSharedEdges: + if geompy.NbShapes(face, geompy.ShapeType["VERTEX"]) > 1: # edge non degeneree + sharedEdges.append(face) + for i_aux, edge in enumerate(sharedEdges): + name = "edgeCommuneEllipsoideBloc_{}".format(i_aux) + geomPublishInFather(initLog.debug,blocp, edge, name) + + facesExternes = list() + facesExtBloc = list() + facesExtElli = list() faces = geompy.ExtractShapes(facesDefaut, geompy.ShapeType["FACE"], True) - if len(faces) == 0: + if not faces: faces = [facesDefaut] - for i in range(len(faces)): - faceExt = geompy.GetInPlace(ellipsoidep, faces[i]) + for i_aux, face in enumerate(faces): + faceExt = geompy.GetInPlace(ellipsoidep, face) if faceExt is not None: - name = "faceExterne_e%d"%i + name = "faceExterne_e{}".format(i_aux) geomPublishInFather(initLog.debug,ellipsoidep, faceExt, name) facesExternes.append(faceExt) facesExtElli.append(faceExt) - faceExt = geompy.GetInPlace(blocp, faces[i]) + faceExt = geompy.GetInPlace(blocp, face) if faceExt is not None: - name = "faceExterne_b%d"%i + name = "faceExterne_b{}".format(i_aux) geomPublishInFather(initLog.debug,blocp, faceExt, name) facesExternes.append(faceExt) facesExtBloc.append(faceExt) else: logging.info(" recherche faces externes par GetShapesOnShape") - vertex = geompy.MakeVertexOnSurface(faces[i], 0.5, 0.5) - normal = geompy.GetNormal(faces[i], vertex) - extrusionFace = geompy.MakePrismVecH(faces[i], normal, 1) - #extrusionFace = geompy.MakePrismVecH2Ways(faces[i], normal, 0.1) + vertex = geompy.MakeVertexOnSurface(face, 0.5, 0.5) + normal = geompy.GetNormal(face, vertex) + extrusionFace = geompy.MakePrismVecH(face, normal, 1) + #extrusionFace = geompy.MakePrismVecH2Ways(face, normal, 0.1) #extrusionFace = geompy.MakeScaleTransform(extrusionFace, vertex, 1.01) - name = "extrusionFace_b%d"%i + name = "extrusionFace_b{}".format(i_aux) geomPublishInFather(initLog.debug,blocp, extrusionFace, name) #facesExt = geompy.GetShapesOnShape(extrusionFace, blocp, geompy.ShapeType["FACE"], GEOM.ST_ONIN) facesExt = geompy.GetShapesOnShape(extrusionFace, blocp, geompy.ShapeType["FACE"], GEOM.ST_ON) - for j in range(len(facesExt)): - name = "faceExterne_b%d_%d"%(i,j) - geomPublishInFather(initLog.debug,blocp, facesExt[j], name) - facesExternes.append(facesExt[j]) - facesExtBloc.append(facesExt[j]) + for j_aux, face_ext in enumerate(facesExt): + name = "faceExterne_b{}_{}".format(i_aux,j_aux) + geomPublishInFather(initLog.debug,blocp, face_ext, name) + facesExternes.append(face_ext) + facesExtBloc.append(face_ext) if len(facesExtBloc) < len(faces): # toutes les faces externes du bloc n'ont pas été trouvées. TODO eliminer les detections multiples logging.info(" recherche faces externes par aretes partagees avec faces externes ellipsoide") facesBloc = geompy.ExtractShapes(blocp, geompy.ShapeType["FACE"], True) - for i in range(len(facesBloc)): + for i_aux, face in enumerate(facesBloc): notOnEllipsoide = True - for j in range(len(sharedFaces)): # eliminer les faces communes avec l'ellipsoide - if facesBloc[i].IsSame(sharedFaces[j]): + for j_aux, sharedface in enumerate(sharedFaces): # eliminer les faces communes avec l'ellipsoide + if face.IsSame(sharedface): notOnEllipsoide = False break if notOnEllipsoide: - for j in range(len(facesExtElli)): # les faces recherchees ont une ou plusieurs edge communes avec la ou les faces externes de l'ellipsoide - allSharedEdges = [] + for j_aux, face_ext_elli in enumerate(facesExtElli): # les faces recherchees ont une ou plusieurs edge communes avec la ou les faces externes de l'ellipsoide + allSharedEdges = list() try: - allSharedEdges += geompy.GetSharedShapesMulti([facesBloc[i], facesExtElli[j]], geompy.ShapeType["EDGE"]) + allSharedEdges += geompy.GetSharedShapesMulti([face, face_ext_elli], geompy.ShapeType["EDGE"]) except: pass - if len(allSharedEdges) > 0: - name = "faceExterne_b%d_%d"%(i,j) - geomPublishInFather(initLog.debug,blocp, facesBloc[i], name) - facesExternes.append(facesBloc[i]) - facesExtBloc.append(facesBloc[i]) - - aretesInternes = [] - for i in range(len(facesExternes)): - for j in range(i+1,len(facesExternes)): - shared = [] + if allSharedEdges: + name = "faceExterne_b{}_{}".format(i_aux,j_aux) + geomPublishInFather(initLog.debug,blocp, face, name) + facesExternes.append(face) + facesExtBloc.append(face) + + aretesInternes = list() + for i_aux, face_ext_i in enumerate(facesExternes): + for j_aux, face_ext_j in enumerate(facesExternes[i_aux+1:]): + shared = list() try: - shared += geompy.GetSharedShapesMulti([facesExternes[i], facesExternes[j]], geompy.ShapeType["EDGE"]) + shared += geompy.GetSharedShapesMulti([face_ext_i, face_ext_j], geompy.ShapeType["EDGE"]) except: - logging.info("no shared edges in %s,%s",i,j) + texte = "no shared edges in {},{}".format(i_aux,j_aux) + logging.info(texte) else: aretesInternes += shared - for i in range(len(aretesInternes)): - name = "aretesInternes_%d"%i - geomPublishInFather(initLog.debug,blocp, aretesInternes[i], name) + for i_aux, edge in enumerate(aretesInternes): + name = "aretesInternes_{}".format(i_aux) + geomPublishInFather(initLog.debug,blocp, edge, name) - edgesBords = [] + l_edgesBords = list() for faceExtB in facesExtBloc: edges = geompy.ExtractShapes(faceExtB, geompy.ShapeType["EDGE"], True) - for i in range(len(edges)): + for i_aux, edge in enumerate(edges): isInterne = False - for j in range(len(aretesInternes)): - if edges[i].IsSame(aretesInternes[j]): + for arete in aretesInternes: + if edge.IsSame(arete): isInterne = True break if not isInterne: - edgesBords.append(edges[i]) - name = "edgeBord%d"%i - geomPublishInFather(initLog.debug,blocp,edges[i] , name) - group = None - if len(edgesBords) > 0: - group = geompy.CreateGroup(blocp, geompy.ShapeType["EDGE"]) - geompy.UnionList(group, edgesBords) - edgesBords = group + l_edgesBords.append(edge) + name = "edgeBord{}".format(i_aux) + geomPublishInFather(initLog.debug,blocp,edge , name) + if l_edgesBords: + edgesBords = geompy.CreateGroup(blocp, geompy.ShapeType["EDGE"]) + geompy.UnionList(edgesBords, l_edgesBords) + else: + edgesBords = None return volDefautPart, blocp, tore, faceFissure, facesExternes, facesExtBloc, facesExtElli, aretesInternes, ellipsoidep, sharedFaces, sharedEdges, edgesBords diff --git a/src/Tools/blocFissure/gmu/partitionVolumeSain.py b/src/Tools/blocFissure/gmu/partitionVolumeSain.py index 66bd0bdb1..5e3bf41f6 100644 --- a/src/Tools/blocFissure/gmu/partitionVolumeSain.py +++ b/src/Tools/blocFissure/gmu/partitionVolumeSain.py @@ -17,15 +17,15 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Partition volume sain et bloc, face du bloc recevant la fissure""" import logging + from .geomsmesh import geompy from .geomsmesh import geomPublish from .geomsmesh import geomPublishInFather -from . import initLog -# ----------------------------------------------------------------------------- -# --- partition volume sain et bloc, face du bloc recevant la fissure +from . import initLog def partitionVolumeSain(volumeSain,boiteDefaut): """ diff --git a/src/Tools/blocFissure/gmu/partitionneFissureParPipe.py b/src/Tools/blocFissure/gmu/partitionneFissureParPipe.py index 199798f48..94531de72 100644 --- a/src/Tools/blocFissure/gmu/partitionneFissureParPipe.py +++ b/src/Tools/blocFissure/gmu/partitionneFissureParPipe.py @@ -17,16 +17,19 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Pipe de fond de fissure, prolongé, partition face fissure par pipe""" -import math import logging +import math +import traceback + from .geomsmesh import geompy from .geomsmesh import geomPublish from .geomsmesh import geomPublishInFather + from . import initLog from .findWireEndVertices import findWireEndVertices from .prolongeWire import prolongeWire -import traceback from .fissError import fissError def partitionneFissureParPipe(shapesFissure, elementsDefaut, rayonPipe): @@ -46,7 +49,7 @@ def partitionneFissureParPipe(shapesFissure, elementsDefaut, rayonPipe): #fondFissCoupe = geompy.GetInPlaceByHistory(shapeDefaut, fondFiss) #= inutile geomPublish(initLog.debug, shapeDefaut, 'shapeDefaut_coupe') #geomPublishInFather(initLog.debug,shapeDefaut, fondFissCoupe, 'fondFiss_coupe') - + extrem, norms = findWireEndVertices(fondFiss, True) logging.debug("extrem: %s, norm: %s",extrem, norms) cercle = geompy.MakeCircle(extrem[0], norms[0], rayonPipe) @@ -66,10 +69,10 @@ def partitionneFissureParPipe(shapesFissure, elementsDefaut, rayonPipe): geomPublish(initLog.debug, fissPipe, 'fissPipe') partPipe = geompy.GetInPlaceByHistory(partFissPipe, pipeFiss) geomPublish(initLog.debug, partPipe, 'partPipe') - + edgesPipeFiss = geompy.GetSharedShapesMulti([fissPipe, partPipe], geompy.ShapeType["EDGE"]) - for i, edge in enumerate(edgesPipeFiss): - name = "edgePipe%d"%i + for i_aux, edge in enumerate(edgesPipeFiss): + name = "edgePipe{}".format(i_aux) geomPublishInFather(initLog.debug,fissPipe, edge, name) try: wirePipeFiss = geompy.MakeWire(edgesPipeFiss) @@ -77,13 +80,13 @@ def partitionneFissureParPipe(shapesFissure, elementsDefaut, rayonPipe): wirePipeFiss = geompy.MakeCompound(edgesPipeFiss) logging.debug("wirePipeFiss construit sous forme de compound") geomPublish(initLog.debug, wirePipeFiss, "wirePipeFiss") - + wireFondFiss = geompy.GetInPlace(partFissPipe,fondFiss) edgesFondFiss = geompy.GetSharedShapesMulti([fissPipe, wireFondFiss], geompy.ShapeType["EDGE"]) - for i, edge in enumerate(edgesFondFiss): - name = "edgeFondFiss%d"%i + for i_aux, edge in enumerate(edgesFondFiss): + name = "edgeFondFiss{}".format(i_aux) geomPublishInFather(initLog.debug,fissPipe, edge, name) wireFondFiss = geompy.MakeWire(edgesFondFiss) - geomPublish(initLog.debug, wireFondFiss,"wireFondFiss") + geomPublish(initLog.debug, wireFondFiss,"wireFondFiss") - return (fissPipe, edgesPipeFiss, edgesFondFiss, wirePipeFiss, wireFondFiss) \ No newline at end of file + return (fissPipe, edgesPipeFiss, edgesFondFiss, wirePipeFiss, wireFondFiss) diff --git a/src/Tools/blocFissure/gmu/peauInterne.py b/src/Tools/blocFissure/gmu/peauInterne.py index 640326b47..6c241a75c 100644 --- a/src/Tools/blocFissure/gmu/peauInterne.py +++ b/src/Tools/blocFissure/gmu/peauInterne.py @@ -17,19 +17,19 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Peau interne du defaut dans le maillage sain""" import logging -from .geomsmesh import smesh -import SMESH import traceback -from .fissError import fissError +import SMESH + +from .geomsmesh import smesh + +from .fissError import fissError from .listOfExtraFunctions import lookForCorner from .fusionMaillageAttributionDefaut import fusionMaillageDefaut -# ----------------------------------------------------------------------------- -# --- peau interne du defaut dans le maillage sain - def peauInterne(fichierMaillage, shapeDefaut, nomZones): """Retrouve les groupes de défaut dans le maillage sain modifié par CreateHoleSkin (CreeZoneDefautMaillage) @@ -37,7 +37,7 @@ def peauInterne(fichierMaillage, shapeDefaut, nomZones): Remarque : intérêt du passage par fichierMaillage plutôt que par maillageSain ? """ logging.info("start") - ([maillageSain], status) = smesh.CreateMeshesFromMED(fichierMaillage) + ([maillageSain], _) = smesh.CreateMeshesFromMED(fichierMaillage) groups = maillageSain.GetGroups() #print ("groupes :") @@ -78,7 +78,7 @@ def peauInterne(fichierMaillage, shapeDefaut, nomZones): for entity_type in info: #print (". {} : {})".format(entity_type, info[entity_type])) nbelem += info[entity_type] - if ("Entity_Hexa" == str(entity_type)): + if ( str(entity_type) == "Entity_Hexa" ): nbhexa += info[entity_type] nbhexa += info[entity_type] #print ("==> nbelem = {}, nbhexa = {}".format(nbelem,nbhexa)) @@ -92,16 +92,16 @@ def peauInterne(fichierMaillage, shapeDefaut, nomZones): texte += "
  • Il n'y a pas que des hexaèdres réglés linéaires dans la zone à remailler (notamment mailles quadratiques, tetraèdres non traités)
    • " raise fissError(traceback.extract_stack(),texte) - nbAdded, maillageSain, DefautBoundary = maillageSain.MakeBoundaryElements( SMESH.BND_2DFROM3D, 'DefBound', '', 0, [ zoneDefaut ]) + _, maillageSain, DefautBoundary = maillageSain.MakeBoundaryElements( SMESH.BND_2DFROM3D, 'DefBound', '', 0, [ zoneDefaut ]) internal = maillageSain.GetMesh().CutListOfGroups( [ DefautBoundary ], [ zoneDefaut_skin ], 'internal' ) internalBoundary = smesh.CopyMesh( internal, 'internalBoundary', 0, 0) maillageDefautCible = smesh.CopyMesh(zoneDefaut_skin, 'maillageCible', 0, 0) listOfCorner = lookForCorner(maillageDefautCible) - logging.debug("listOfCorner = {}".format(listOfCorner)) + texte = "listOfCorner = {}".format(listOfCorner) + logging.debug(texte) if listOfCorner: - logging.info("présence de coins à la surface externe de la zone à reconstruire") - zoneDefaut_skin, internalBoundary = fusionMaillageDefaut(maillageSain, maillageDefautCible, internalBoundary, zoneDefaut_skin, shapeDefaut, listOfCorner) + logging.info("présence de coins à la surface externe de la zone à reconstruire") + zoneDefaut_skin, internalBoundary = fusionMaillageDefaut(maillageSain, maillageDefautCible, internalBoundary, zoneDefaut_skin, shapeDefaut, listOfCorner) return maillageSain, internalBoundary, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges - diff --git a/src/Tools/blocFissure/gmu/produitMixte.py b/src/Tools/blocFissure/gmu/produitMixte.py index 59d709aed..502b8d2ec 100644 --- a/src/Tools/blocFissure/gmu/produitMixte.py +++ b/src/Tools/blocFissure/gmu/produitMixte.py @@ -17,25 +17,26 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Calcul de produit mixte pour orientation""" import logging + from .geomsmesh import geompy -# ----------------------------------------------------------------------------- -# --- calcul de produit mixte pour orientation +def produitMixte(origine, point_1, point_2, point_3): + """produit mixte de 3 vecteurs a partir d'une origine et 3 points""" + coordo = geompy.PointCoordinates(origine) + coord_1 = geompy.PointCoordinates(point_1) + coord_2 = geompy.PointCoordinates(point_2) + coord_3 = geompy.PointCoordinates(point_3) + + o_1 = [coord_1[0] - coordo[0], coord_1[1] - coordo[1], coord_1[2] - coordo[2]] + o_2 = [coord_2[0] - coordo[0], coord_2[1] - coordo[1], coord_2[2] - coordo[2]] + o_3 = [coord_3[0] - coordo[0], coord_3[1] - coordo[1], coord_3[2] - coordo[2]] + + prmi = ( o_1[0]*o_2[1]*o_3[2] + o_2[0]*o_3[1]*o_1[2] + o_3[0]*o_1[1]*o_2[2] ) \ + - ( o_1[0]*o_3[1]*o_2[2] + o_2[0]*o_1[1]*o_3[2] + o_3[0]*o_2[1]*o_1[2] ) -def produitMixte(o, p1, p2, p3): - """ - produit mixte de 3 vecteurs a partir d'une origine et 3 points - """ - coordo = geompy.PointCoordinates(o) - coordp1 = geompy.PointCoordinates(p1) - coordp2 = geompy.PointCoordinates(p2) - coordp3 = geompy.PointCoordinates(p3) - u = [coordp1[0] - coordo[0], coordp1[1] - coordo[1], coordp1[2] - coordo[2]] - v = [coordp2[0] - coordo[0], coordp2[1] - coordo[1], coordp2[2] - coordo[2]] - w = [coordp3[0] - coordo[0], coordp3[1] - coordo[1], coordp3[2] - coordo[2]] - pm = (u[0]*v[1]*w[2] + v[0]*w[1]*u[2] + w[0]*u[1]*v[2]) - (u[0]*w[1]*v[2] + v[0]*u[1]*w[2] + w[0]*v[1]*u[2]) - logging.debug('pm=%s', pm) - return pm + logging.debug('prmi=%s', prmi) + return prmi diff --git a/src/Tools/blocFissure/gmu/projettePointSurCourbe.py b/src/Tools/blocFissure/gmu/projettePointSurCourbe.py index 3dab8c290..0701e6c5a 100644 --- a/src/Tools/blocFissure/gmu/projettePointSurCourbe.py +++ b/src/Tools/blocFissure/gmu/projettePointSurCourbe.py @@ -17,47 +17,46 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Projection d'un point sur une courbe.""" -from .geomsmesh import geompy import logging -import math -# ----------------------------------------------------------------------------- -# --- projection d'un point sur une courbe. +from .geomsmesh import geompy -def projettePointSurCourbe(pt, edge): +def projettePointSurCourbe(point, edge): """ projection d'un point p sur une courbe c on suppose que la distance (c(u), p) passe par un minimum quand u varie entre 0 et 1 - et qu'elle presente pas de minimum local + et qu'elle presente pas de minimum local """ #logging.debug("start") - dist = [] - nbSlices = 50 - du = 1.0/nbSlices - for i in range(nbSlices + 1): - p = geompy.MakeVertexOnCurve(edge, du*i) - d = geompy.MinDistance(p,pt) - dist.append((d,i)) + dist = list() + nb_slices = 50 + delta = 1.0/float(nb_slices) + for i_aux in range(nb_slices + 1): + pti = geompy.MakeVertexOnCurve(edge, delta*float(i_aux)) + dpti = geompy.MinDistance(pti,point) + dist.append((dpti,i_aux)) dist.sort() + #logging.debug("dist %s", dist) - umin = du*dist[0][1] - umax = du*dist[1][1] + umin = delta*dist[0][1] + umax = delta*dist[1][1] #umin = 0.0 #umax = 1.0 tol = 1.e-8 pmin = geompy.MakeVertexOnCurve(edge, umin) pmax = geompy.MakeVertexOnCurve(edge, umax) - dmin = geompy.MinDistance(pmin,pt) - dmax = geompy.MinDistance(pmax,pt) + dmin = geompy.MinDistance(pmin,point) + dmax = geompy.MinDistance(pmax,point) dext = geompy.MinDistance(pmin,pmax) - i=0 - while dext > tol and i < 100 : - i = i+1 + i_aux = 0 + while ( ( dext > tol ) and ( i_aux < 100 ) ): + i_aux += 1 utest = (umax + umin) / 2.0 - ptest = geompy.MakeVertexOnCurve(edge, utest) - dtest = geompy.MinDistance(ptest,pt) + ptest = geompy.MakeVertexOnCurve(edge, utest) + dtest = geompy.MinDistance(ptest,point) if dmin < dmax: umax = utest pmax = ptest @@ -68,10 +67,11 @@ def projettePointSurCourbe(pt, edge): dmin = dtest dext = geompy.MinDistance(pmin,pmax) #logging.debug('umin=%s umax=%s dmin=%s dmax=%s dtest=%s dext=%s', umin,umax,dmin,dmax,dtest,dext) - if abs(utest) < 1.e-7: + + if ( abs(utest) < 1.e-7 ): utest = 0.0 - if abs(1.0-utest) < 1.e-7: + elif ( abs(1.0-utest) < 1.e-7 ): utest = 1.0 - logging.debug('u=%s, nbiter=%s dtest=%s dext=%s',utest,i,dtest,dext) + logging.debug('u=%s, nbiter=%s dtest=%s dext=%s',utest,i_aux,dtest,dext) + return utest - \ No newline at end of file diff --git a/src/Tools/blocFissure/gmu/prolongeVertices.py b/src/Tools/blocFissure/gmu/prolongeVertices.py index b5d0f0468..3b57fb029 100644 --- a/src/Tools/blocFissure/gmu/prolongeVertices.py +++ b/src/Tools/blocFissure/gmu/prolongeVertices.py @@ -17,30 +17,29 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Prolongation des segments extrémités des polylines, pour la découpe""" import logging -from .geomsmesh import geompy -# ----------------------------------------------------------------------------- -# --- prolongation des segments extremité des polylines, pour la découpe +from .geomsmesh import geompy def prolongeVertices(vertices): """ Prolongation des segments extremité d'une polyline définie par un vecteur de points. - Chaque nouvelle extremité est obtenue par symétrie point du voisin de cette ancienne extrémité - (symétrie de centre l'ancienne extrémite) : les segments extremes sont doublés. + Chaque nouvelle extrémité est obtenue par symétrie point du voisin de cette ancienne extrémité + (symétrie de centre l'ancienne extrémite) : les segments extrêmes sont doublés. @param vertices : liste ordonnée des points (geomObject) de la polyline @return vertices : liste avec les deux extremités modifiées """ logging.info("start") if len(vertices) < 2: return vertices - v0 = vertices[0] - v1 = vertices[1] - m0 = geompy.MakeMirrorByPoint(v1, v0) - ve = vertices[-1] - vd = vertices[-2] - m1 = geompy.MakeMirrorByPoint(vd, ve) - vertices[0] = m0 - vertices[-1] = m1 + + m_0 = geompy.MakeMirrorByPoint(vertices[1], vertices[0]) + + m_1 = geompy.MakeMirrorByPoint(vertices[-2], vertices[-1]) + + vertices[0] = m_0 + vertices[-1] = m_1 + return vertices diff --git a/src/Tools/blocFissure/gmu/prolongeWire.py b/src/Tools/blocFissure/gmu/prolongeWire.py index b35db538b..04cceb9ab 100644 --- a/src/Tools/blocFissure/gmu/prolongeWire.py +++ b/src/Tools/blocFissure/gmu/prolongeWire.py @@ -17,38 +17,40 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Prolongation d'un wire par deux segments tangents""" import logging + from .geomsmesh import geompy from .geomsmesh import geomPublish -from .geomsmesh import geomPublishInFather + from . import initLog -from .orderEdgesFromWire import orderEdgesFromWire -# ----------------------------------------------------------------------------- -# --- prolongation d'un wire par deux segments tangents +from .orderEdgesFromWire import orderEdgesFromWire -def prolongeWire(aWire, extrem, norms, lg): - """ - """ +def prolongeWire(aWire, extrem, norms, longueur): + """Prolongation d'un wire par deux segments tangents""" logging.info("start") - if geompy.NumberOfEdges(aWire) > 1: + + if ( geompy.NumberOfEdges(aWire) > 1 ): edges = geompy.ExtractShapes(aWire, geompy.ShapeType["EDGE"]) uneSeuleEdge = False else: edges = [aWire] uneSeuleEdge = True - edgesBout = [] - for i, v1 in enumerate(extrem): - exts = [geompy.MakeTranslationVectorDistance(v1, norms[i], l) for l in (-lg, lg)] - dists = [(geompy.MinDistance(v, aWire), i , v) for i, v in enumerate(exts)] + + edgesBout = list() + for i_aux, v_1 in enumerate(extrem): + exts = [geompy.MakeTranslationVectorDistance(v_1, norms[i_aux], lg_aux) for lg_aux in (-longueur, longueur)] + dists = [(geompy.MinDistance(v, aWire), j_aux , v) for j_aux, v in enumerate(exts)] dists.sort() - v2 = dists[-1][-1] - edge = geompy.MakeEdge(v1, v2) + v_2 = dists[-1][-1] + edge = geompy.MakeEdge(v_1, v_2) edges.append(edge) edgesBout.append(edge) - name = "extrem%d"%i + name = "extrem{}".format(i_aux) geomPublish(initLog.debug, edge, name) + try: wireProlonge = geompy.MakeWire(edges) geomPublish(initLog.debug, wireProlonge, "wireProlonge") @@ -61,16 +63,19 @@ def prolongeWire(aWire, extrem, norms, lg): edgelist, accessList = orderEdgesFromWire(aWire) edge1 = edgelist[accessList[0]] if geompy.MinDistance(edgesBout[0], edge1) < 1.e-4 : - i0 = 0 - i1 = 1 + i_0 = 0 + i_1 = 1 else: - i0 = 1 - i1 = 0 - wireProlonge = edgesBout[i0] - for i in range(len(edgelist)): - wireProlonge = geompy.MakeWire([wireProlonge, edgelist[accessList[i]]]) - geomPublish(initLog.debug, wireProlonge, "wireProlonge_%d"%i) - wireProlonge = geompy.MakeWire([wireProlonge,edgesBout[i1]]) + i_0 = 1 + i_1 = 0 + wireProlonge = edgesBout[i_0] + + for i_aux in range(len(edgelist)): + wireProlonge = geompy.MakeWire([wireProlonge, edgelist[accessList[i_aux]]]) + geomPublish(initLog.debug, wireProlonge, "wireProlonge_{}".format(i_aux)) + + wireProlonge = geompy.MakeWire([wireProlonge,edgesBout[i_1]]) geomPublish(initLog.debug, wireProlonge, "wireProlonge") logging.warning("prolongation wire pas a pas OK") + return wireProlonge