--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+\r
+# %% LICENSE_SALOME_CEA_BEGIN\r
+# Copyright (C) 2008-2016 CEA/DEN\r
+# \r
+# This library is free software; you can redistribute it and/or\r
+# modify it under the terms of the GNU Lesser General Public\r
+# License as published by the Free Software Foundation; either\r
+# version 2.1 of the License, or (at your option) any later version.\r
+# \r
+# This library is distributed in the hope that it will be useful,\r
+# but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r
+# Lesser General Public License for more details.\r
+# \r
+# You should have received a copy of the GNU Lesser General Public\r
+# License along with this library; if not, write to the Free Software\r
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r
+# \r
+# See http://www.salome-platform.org or email : webmaster.salome@opencascade.com\r
+# %% LICENSE_END\r
+\r
+\r
+"""\r
+run coherency tests on one and some mesh.\r
+initially used for test output(s) mg_tetra_hpc_mpi.exe\r
+\r
+WARNING: is for small meshes, obviously no optimisation.\r
+WARNING: printing and .mesh indices are 1 to n when stored list python 0 to n-1\r
+\r
+example linux usage:\r
+- simple run:\r
+ ./testMesh.py --verbose --testall --files ./GHS3DPRL_out.000001.mesh ./GHS3DPRL_out.000002.mesh\r
+ ./testMesh.py -a -f /tmp/GHS3DPRL_out.00000?.mesh\r
+"""\r
+\r
+import os\r
+import sys\r
+import platform\r
+import argparse as AP\r
+import pprint as PP #pretty print\r
+\r
+verbose = False\r
+\r
+OK = "ok"\r
+KO = "KO"\r
+OKSYS = 0 #for linux\r
+KOSYS = 1 #for linux\r
+\r
+\r
+#########################################\r
+# utilities\r
+\r
+def okToSys(aResult, verbose=False):\r
+ """to get windows or linux result of script"""\r
+
+ def extendList(alist):
+ """utility extend list of lists of string results with ok or KO"""\r
+ #bad: list(itertools.chain.from_list(alist)) iterate on str\r
+ res = []\r
+ if type(alist) != list:\r
+ return [alist]\r
+ else:\r
+ for i in alist:\r
+ if type(i) == str:\r
+ res.append(i)\r
+ else:\r
+ res.extend(extendList(i))\r
+ return res\r
+ \r
+ resList = extendList(aResult)\r
+ if resList == []:\r
+ if verbose: print("WARNING: result no clear: []")\r
+ return KOSYS\r
+ \r
+ rr = OK\r
+ for ri in resList:\r
+ if ri[0:2] != OK:\r
+ if verbose: print ri\r
+ rr = KO\r
+\r
+ if verbose: print("INFO: result: %s" % rr)\r
+ if rr == OK:\r
+ return OKSYS\r
+ else:\r
+ return KOSYS\r
+\r
+def getDirAndName(datafile):\r
+ path, namefile = os.path.split(os.path.realpath(datafile))\r
+ rootpath = os.getcwd()\r
+ return (path, rootpath, namefile)\r
+\r
+def resumeList(aList):\r
+ if len(aList) == 0: \r
+ return []\r
+ if len(aList) < 3:\r
+ return aList\r
+ res = [aList[0], "...", aList[-1]]\r
+ return res\r
+\r
+def resumeLines(aList, ilines):\r
+ if verbose: print("INFO: resumeLines", ilines)\r
+ if len(aList) == 0: \r
+ return []\r
+ if len(aList) < 3:\r
+ return aList\r
+ res = []\r
+ for i in ilines:
+ if i != None: # if not existing tetrahedra for example\r
+ resi = [ii.strip("\n") for ii in aList[i:i+4]]\r
+ resi.append("...")\r
+ res.append(resi)\r
+ return res\r
+\r
+\r
+#########################################\r
+class XXVert(object): \r
+ """Vertices, Nodes"""\r
+ def __init__(self, x, y, z, color=0, indexglobal=0):\r
+ self.x = x\r
+ self.y = y\r
+ self.z = z\r
+ self.color = color\r
+ self.indexglobal = indexglobal\r
+\r
+ def compare(self, vb, args, withAll=True):\r
+ if self.x != vb.x: return False\r
+ if self.y != vb.y: return False\r
+ if self.z != vb.z: return False\r
+ if withAll:\r
+ if args.withColor:\r
+ if self.color != vb.color: return False\r
+ if args.withIndex:\r
+ if self.indexglobal != vb.indexglobal: return False\r
+ return True\r
+\r
+ def __eq__(self, vb):\r
+ """equality test without color or indexglobal"""\r
+ #print "vertice equality"\r
+ if self.x != vb.x: return False\r
+ if self.y != vb.y: return False\r
+ if self.z != vb.z: return False\r
+ return True\r
+\r
+ def __ne__(self, vb):\r
+ """inequality test without color or indexglobal"""\r
+ #print "vertice inequality"\r
+ if self.x == vb.x and self.y == vb.y and self.z != vb.z: \r
+ return True\r
+ return False\r
+\r
+ def __repr__(self):\r
+ return "XXVert(%.4f %.4f %.4f (%i %i))" % \\r
+ (self.x, self.y, self.z, self.color, self.indexglobal)\r
+\r
+ def __str__(self):\r
+ return "(%s %s %s (%i %i))" % \\r
+ (self.x, self.y, self.z, self.color, self.indexglobal)\r
+\r
+ def dist(self, vb):\r
+ res = (self.x - vb.x)**2 + (self.y - vb.y)**2 + (self.z -vb.z)**2\r
+ return res**.5\r
+\r
+\r
+\r
+#########################################\r
+class XXEdge(object):\r
+ """Edges, 2 Nodes"""\r
+ def __init__(self, a, b, color=0, indexglobal=0):\r
+ self.a = a\r
+ self.b = b\r
+ self.color = color\r
+ self.indexglobal = indexglobal\r
+\r
+ def compare(self, eb, args):\r
+ res = self.a.compare(eb.a, args) and \\r
+ self.b.compare(eb.b, args)\r
+ if res:\r
+ if args.withColor:\r
+ if self.color != eb.color: return False\r
+ if args.withIndex:\r
+ if self.indexglobal != eb.indexglobal: return False\r
+ return res\r
+\r
+ def __repr__(self):\r
+ return "XXEdge(%i %i (%i %i))" % \\r
+ (self.a, self.b, self.color, self.indexglobal)\r
+\r
+ def __str__(self):\r
+ return "(%i %i (%i %i))" % \\r
+ (self.a, self.b, self.color, self.indexglobal)\r
+\r
+ def inTria(self, tria, args):\r
+ t = [tria.a, tria.b, tria.c]\r
+ if not self.a in t: return False\r
+ if not self.b in t: return False\r
+ return True\r
+\r
+ def getVertices(self, mesh):\r
+ v1 = mesh.verts[self.a - 1]\r
+ v2 = mesh.verts[self.b - 1]\r
+ return [v1, v2]\r
+\r
+\r
+#########################################\r
+class XXTria(object):\r
+ """Triangles, Faces, 3 nodes"""\r
+ def __init__(self, a, b, c, color=0, indexglobal=0):\r
+ self.a = a\r
+ self.b = b\r
+ self.c = c\r
+ self.color = color\r
+ self.indexglobal = indexglobal\r
+\r
+ def compare(self, trb, args):\r
+ res = self.a.compare(trb.a, args) and \\r
+ self.b.compare(trb.b, args) and \\r
+ self.c.compare(trb.c, args)\r
+ if res:\r
+ if args.withColor:\r
+ if self.color != trb.color: return False\r
+ if args.withIndex:\r
+ if self.indexglobal != trb.indexglobal: return False\r
+ return res\r
+\r
+ def __repr__(self):\r
+ return "XXTria(%i %i %i (%i %i))" % \\r
+ (self.a, self.b, self.c, self.color, self.indexglobal)\r
+\r
+ def __str__(self):\r
+ return "(%i %i %i (%i %i))" % \\r
+ (self.a, self.b, self.c, self.color, self.indexglobal)\r
+\r
+ def inTetra(self, tetra, args):\r
+ t = [tetra.a, tetra.b, tetra.c, tetra.d]\r
+ if not self.a in t: return False\r
+ if not self.b in t: return False\r
+ if not self.c in t: return False\r
+ return True\r
+\r
+ def getVertices(self, mesh):\r
+ v1 = mesh.verts[self.a - 1]\r
+ v2 = mesh.verts[self.b - 1]\r
+ v3 = mesh.verts[self.c - 1]\r
+ return [v1, v2, v3]\r
+\r
+\r
+\r
+#########################################\r
+class XXTetra(object):\r
+ """Tetra, 4 nodes"""\r
+ def __init__(self, a, b, c, d, color=0, indexglobal=0):\r
+ self.a = a\r
+ self.b = b\r
+ self.c = c\r
+ self.d = d\r
+ self.color = color\r
+ self.indexglobal = indexglobal\r
+\r
+ def compare(self, teb, args):\r
+ res = self.a.compare(teb.a, args) and \\r
+ self.b.compare(teb.b, args) and \\r
+ self.c.compare(teb.c, args) and \\r
+ self.d.compare(teb.d, args)\r
+ if res:\r
+ if args.withColor:\r
+ if self.color != teb.color: return False\r
+ if args.withIndex:\r
+ if self.indexglobal != teb.indexglobal: return False\r
+ return res\r
+\r
+ def __repr__(self):\r
+ return "XXTetra(%i %i %i %i (%i %i))" % \\r
+ (self.a, self.b, self.c, self.d, self.color, self.indexglobal)\r
+\r
+ def __str__(self):\r
+ return "(%i %i %i %i (%i %i))" % \\r
+ (self.a, self.b, self.c, self.d, self.color, self.indexglobal)\r
+\r
+ def getVertices(self, mesh):\r
+ v1 = mesh.verts[self.a - 1]\r
+ v2 = mesh.verts[self.b - 1]\r
+ v3 = mesh.verts[self.c - 1]\r
+ v4 = mesh.verts[self.d - 1]\r
+ return [v1, v2, v3, v4]\r
+\r
+\r
+#########################################\r
+class XXMesh(object):\r
+ """Mesh: vertices, edges, triangles, tetrahedra"""\r
+ def __init__(self):\r
+ self.nameFile = ""\r
+ self.verts = []\r
+ self.edges = []\r
+ self.trias = []\r
+ self.tetras = []\r
+\r
+ def initFromFileMesh(self, fileName, args, withGlobal=True):\r
+ if not os.path.isfile(fileName):\r
+ raise Exception("ERROR: inexisting file '%s'" % fileName)\r
+ with open(fileName, "r") as f:\r
+ lines = f.readlines()\r
+ iverts, iedges, itrias, itetras = self.getIndexInMeshFile(lines)\r
+ self.verts = self.getMeshVerts(lines, iverts)\r
+ self.edges = self.getMeshEdges(lines, iedges)\r
+ self.trias = self.getMeshTrias(lines, itrias)\r
+ self.tetras = self.getMeshTetras(lines, itetras)\r
+ self.nameFile = fileName\r
+ if args.globalNumerotation == True and withGlobal==True:\r
+ self.initFromFileGlobal(fileName, args)\r
+ if verbose: \r
+ print("\nINFO: initFromFileMesh: read file: %s" % str(self))\r
+ print(self.strResume())\r
+ print(PP.pformat(resumeLines(lines, [iverts, iedges, itrias, itetras])))\r
+\r
+ def initFromFileGlobal(self, fileNameMeshOrGlobal, args):\r
+ shortname, extension = os.path.splitext(fileNameMeshOrGlobal)\r
+ if extension == ".mesh":\r
+ fileName = shortname + ".global"\r
+ elif extension == "global":\r
+ fileName = fileNameMeshOrGlobal\r
+ else:\r
+ raise Exception("ERROR: initFromFileGlobal: unexpected file '%s'" % fileName)\r
+ if not os.path.isfile(fileName):\r
+ raise Exception("ERROR: initFromFileGlobal: inexisting file '%s'" % fileName)\r
+ \r
+ with open(fileName, "r") as f:\r
+ lines = f.readlines()\r
+ nbverts, nbedges, nbtrias, nbtetras = [int(i) for i in lines[0].split()]\r
+ if verbose:\r
+ print("\nINFO: initFromFileGlobal: read file: %s" % str(self))\r
+ print(" nbverts %i\n nbedges %i\n nbtrias %i\n nbtetras %i" % (nbverts, nbedges, nbtrias, nbtetras))\r
+ if nbverts != len(self.verts): \r
+ raise Exception("ERROR: in file '%s' unexpected number of Vertices %i<>%i" % (fileName, nbverts, len(self.verts)))\r
+ if nbedges != len(self.edges): \r
+ raise Exception("ERROR: in file '%s' unexpected number of Edges %i<>%i" % (fileName, nbedges, len(self.edges)))\r
+ if nbtrias != len(self.trias): \r
+ raise Exception("ERROR: in file '%s' unexpected number of Triangles %i<>%i" % (fileName, nbtrias, len(self.trias)))\r
+ if nbtetras != len(self.tetras): \r
+ raise Exception("ERROR: in file '%s' unexpected number of Tetrahedra %i<>%i" % (fileName, nbtetras, len(self.tetras)))\r
+ i = 1 #begin index line 1\r
+ for ii in range(nbverts):\r
+ self.verts[ii].indexglobal = long(lines[i])\r
+ i +=1\r
+ for ii in range(nbedges):\r
+ self.edges[ii].indexglobal = long(lines[i])\r
+ i +=1\r
+ for ii in range(nbtrias):\r
+ self.trias[ii].indexglobal = long(lines[i])\r
+ i +=1\r
+ for ii in range(nbtetras):\r
+ self.tetras[ii].indexglobal = long(lines[i])\r
+ i +=1\r
+\r
+\r
+ def __repr__(self):\r
+ return "XXMesh(nameFile='%s', nbverts=%i, nbedges=%i, nbtrias=%i, nbtetras=%i)" % \\r
+ (self.nameFile, len(self.verts), len(self.edges), len(self.trias), len(self.tetras))\r
+\r
+ def strResume(self):\r
+ res = str(self)\r
+ contents = {\r
+ "Vertices": resumeList(self.verts),\r
+ "Edges": resumeList(self.edges),\r
+ "Triangles": resumeList(self.trias),\r
+ "Tetrahedra": resumeList(self.tetras),\r
+ }\r
+ res = res + "\n" + PP.pformat(contents)\r
+ return res\r
+\r
+ def getIndexInMeshFile(self, lines):\r
+ res = []\r
+ for s in ["Vertices", "Edges", "Triangles", "Tetrahedra"]:\r
+ try:\r
+ i = lines.index(s+"\n")\r
+ except:\r
+ i = None\r
+ res.append(i)\r
+ return res\r
+\r
+ def getMeshVerts(self, lines, i):\r
+ res=[]\r
+ try:\r
+ idep = i+2\r
+ ilen = int(lines[i+1])\r
+ ifin = idep+ilen\r
+ for line in lines[idep:ifin]:\r
+ li = line.split(" ")\r
+ x, y, z, color = float(li[0]), float(li[1]), float(li[2]), int(li[3])\r
+ res.append(XXVert(x, y, z, color))\r
+ return res\r
+ except:\r
+ return res\r
+\r
+ def getMeshEdges(self, lines, i):\r
+ res=[]\r
+ try:\r
+ idep = i+2\r
+ ilen = int(lines[i+1])\r
+ ifin = idep+ilen\r
+ for line in lines[idep:ifin]:\r
+ li = line.split(" ")\r
+ a, b, color = int(li[0]), int(li[1]), int(li[2])\r
+ res.append(XXEdge(a, b, color))\r
+ return res\r
+ except:\r
+ return res\r
+\r
+ def getMeshTrias(self, lines, i):\r
+ res=[]\r
+ try:\r
+ idep = i+2\r
+ ilen = int(lines[i+1])\r
+ ifin = idep+ilen\r
+ for line in lines[idep:ifin]:\r
+ li = line.split(" ")\r
+ a, b, c, color = int(li[0]), int(li[1]), int(li[2]), int(li[3])\r
+ res.append(XXTria(a, b, c, color))\r
+ return res\r
+ except:\r
+ return res\r
+\r
+ def getMeshTetras(self, lines, i):\r
+ res=[]\r
+ try:\r
+ idep = i+2\r
+ ilen = int(lines[i+1])\r
+ ifin = idep+ilen\r
+ for line in lines[idep:ifin]:\r
+ li = line.split(" ")\r
+ a, b, c, d, color = int(li[0]), int(li[1]), int(li[2]), int(li[3]), int(li[4])\r
+ res.append(XXTetra(a, b, c, d, color))\r
+ return res\r
+ except:\r
+ return res\r
+\r
+ def haveVertsDistinct(self, args):\r
+ """stop a first KO"""\r
+ i = 0\r
+ verts = self.verts\r
+ for v1 in verts[:-1]:\r
+ i += 1\r
+ j = i\r
+ for v2 in verts[i:]:\r
+ j += 1\r
+ if v1.compare(v2, args):\r
+ #printing indices 1 to n\r
+ print("ERROR: %s vert[%i] equal vert[%i]: v1=%s v2=%s" % (self.nameFile, i, j, v1, v2))\r
+ return KO + " ERROR: %s some equal vertices" % self.nameFile #stop a first KO\r
+ return OK + " INFO: no equal vertices"\r
+\r
+ def getVertices(self, elem):\r
+ """functionnal raccourci to XXElem.getVertices(XXMesh)"""\r
+ return elem.getVertices(self)\r
+\r
+ def compareListOfVertices(self, v1s, v2s, ordered=False):\r
+ """not ordered for now"""\r
+ if ordered:\r
+ res = [i for i, j in zip(v1s, v2s) if i == j]\r
+ return len(res)==len(v1s)\r
+ else: \r
+ res = 0\r
+ for i in v1s:\r
+ for j in v2s:\r
+ if i == j: \r
+ res += 1\r
+ break\r
+ return res==len(v1s)\r
+ \r
+ \r
+ def getCommonVerts(self, mesh, args):\r
+ res = []\r
+ for v1 in self.verts:\r
+ for v2 in mesh.verts:\r
+ if v1.compare(v2, args, withAll=False):\r
+ res.append((v1, v2))\r
+ return res\r
+\r
+ def getVertices(self, elem):\r
+ return elem.getVertices(self)\r
+\r
+ def getCommonEdges(self, mesh, args):\r
+ res = []\r
+ for e1 in self.edges:\r
+ v1s = self.getVertices(e1)\r
+ for e2 in mesh.edges:\r
+ v2s = mesh.getVertices(e2)\r
+ if self.compareListOfVertices(v1s, v2s):\r
+ res.append((e1, e2))\r
+ return res\r
+\r
+ def getCommonTriangles(self, mesh, args):\r
+ res = []\r
+ for e1 in self.trias:\r
+ v1s = self.getVertices(e1)\r
+ for e2 in mesh.trias:\r
+ v2s = mesh.getVertices(e2)\r
+ if self.compareListOfVertices(v1s, v2s):\r
+ res.append((e1, e2))\r
+ return res\r
+\r
+ def getCommonTetras(self, mesh, args):\r
+ res = []\r
+ for e1 in self.tetras:\r
+ v1s = self.getVertices(e1)\r
+ for e2 in mesh.tetras:\r
+ v2s = mesh.getVertices(e2)\r
+ if self.compareListOfVertices(v1s, v2s):\r
+ res.append((e1, e2))\r
+ return res\r
+\r
+ def areEdgesInTrias(self, args):\r
+ """stop a first KO"""\r
+ done = False\r
+ i = 0\r
+ edges = self.edges\r
+ trias = self.trias\r
+ res = OK + " INFO: %s all edges in trias" % self.nameFile\r
+ for e in edges:\r
+ i += 1\r
+ j = 0\r
+ found = False\r
+ for t in trias:\r
+ j += 1\r
+ if e.inTria(t, args):\r
+ #if verbose: print("INFO: %s edges[%i] in trias[%i]: edge=%s tria=%s" % (self.nameFile, i, j, e, t))\r
+ found = True\r
+ break\r
+ if not found:\r
+ print("ERROR: %s edges[%i] not in trias: edge=%s" % (self.nameFile, i, e))\r
+ if verbose and not done: \r
+ print("Triangles:\n%s" % PP.pformat(self.trias))\r
+ done = True\r
+ res = KO+" ERROR: %s some edges not in trias" % (self.nameFile)\r
+ return res\r
+\r
+\r
+ def areTriasInTetras(self, args):\r
+ """no stop a first KO"""\r
+ done = False\r
+ i = 0\r
+ trias = self.trias\r
+ tetras = self.tetras
+ if tetras == []: #supposed skin without tetrahedra
+ res = OK +" WARNING: %s no tetrahedra in mesh" % (self.nameFile)
+ return res\r
+ res = OK + " INFO: %s all trias in tetras" % self.nameFile\r
+ for t in trias:\r
+ i += 1\r
+ j = 0\r
+ found = False\r
+ for h in tetras:\r
+ j += 1\r
+ if t.inTetra(h, args):\r
+ #if verbose: print("INFO: %s trias[%i] in tetras[%i]: tria=%s tetra=%s" % (self.nameFile, i, j, t, h))\r
+ found = True\r
+ break\r
+ if not found:\r
+ if verbose: print("ERROR: %s trias[%i] not in tetras: tria=%s" % (self.nameFile, i, t))\r
+ if verbose and not done: \r
+ print("INFO: Tetrahedra:\n%s" % PP.pformat(self.tetras))\r
+ done = True\r
+ res = KO+" ERROR: %s some trias not in tetras" % (self.nameFile)\r
+ return res\r
+\r
+ def testIntersection(self, mesh, args):\r
+ """intersection coherency between self and mesh"""\r
+\r
+ def storeAndInfoIntersection():\r
+ """used as macro: avoid duplicate code"""\r
+ #store info in args to use later...\r
+ args.intersections[title+name] = commons\r
+ if commons == []:\r
+ res.append(OK + " INFO: no %s" % title+name)\r
+ else:\r
+ res.append(OK + " INFO: existing %s" % title+name)\r
+ return\r
+ \r
+ res=[]\r
+ name = "%s<->%s" % (self.nameFile, mesh.nameFile)\r
+ \r
+ title = "Vertices intersection: "\r
+ commons = self.getCommonVerts(mesh, args)\r
+ storeAndInfoIntersection()\r
+\r
+ title = "Edges intersection: "\r
+ commons = self.getCommonEdges(mesh, args)\r
+ storeAndInfoIntersection()\r
+\r
+ title = "Triangles intersection: "\r
+ commons = self.getCommonTriangles(mesh, args)\r
+ storeAndInfoIntersection()\r
+\r
+ title = "Tetrahedra intersection: "\r
+ commons = self.getCommonTetras(mesh, args)\r
+ storeAndInfoIntersection()\r
+\r
+ return res\r
+ \r
+ def testIndexGlobal(self, mesh, args):\r
+ """global index coherency between self and mesh"""\r
+ \r
+ def storeAndInfoIndexGlobal():\r
+ """used as macro: avoid duplicate code"""\r
+ #store info in args to use later...\r
+ args.indexglobal[title+name] = problems\r
+ if verbose: print("\nINFO: %s\n%s" % (title+name, PP.pformat(problems)))\r
+ if problems == []:\r
+ res.append(OK + " INFO: coherent %s" % title+name)\r
+ else:\r
+ res.append(KO + " ERROR: some problems %s" % title+name)\r
+ return\r
+\r
+ def testIndexGlobal():\r
+ """used as macro: avoid duplicate code"""\r
+ nameElem = title.split(' ')[0]\r
+ #something like 'Vertices intersection: /tmp/GHS3DPRL_out.000002.mesh<->/tmp/GHS3DPRL_out.000003.mesh'\r
+ commonsTitle = nameElem + " intersection: "+ name\r
+ #if verbose: print "testIndexGlobal",title,commonsTitle\r
+ try:\r
+ intersection = args.intersections[commonsTitle]\r
+ except:\r
+ intersection = []\r
+ problems = []\r
+ for ii, jj in intersection:\r
+ if ii.indexglobal != jj.indexglobal:\r
+ problems.append((ii, jj))\r
+ return problems\r
+\r
+ res=[]\r
+ name = "%s<->%s" % (self.nameFile, mesh.nameFile)\r
+\r
+ title = "Vertices indexglobal: "\r
+ problems = testIndexGlobal()\r
+ storeAndInfoIndexGlobal()\r
+\r
+ title = "Edges indexglobal: "\r
+ problems = testIndexGlobal()\r
+ storeAndInfoIndexGlobal()\r
+\r
+ title = "Triangles indexglobal: "\r
+ problems = testIndexGlobal()\r
+ storeAndInfoIndexGlobal()\r
+\r
+ title = "Tetrahedra indexglobal: "\r
+ problems = testIndexGlobal()\r
+ storeAndInfoIndexGlobal()\r
+\r
+ return res\r
+\r
+\r
+#########################################\r
+# tests\r
+ \r
+def testAll(args):
+ """test all on meshes from tetra_hpc_mpi"""\r
+ res = []
+ if verbose: print("\n*****testAll*****\n")
+ args.skinMesh = None
+ if args.skinInputFile != None:
+ args.skinMesh = XXMesh()
+ #a priori no global numerotation file.global for input tetra_hpc_mpi mesh\r
+ args.skinMesh.initFromFileMesh(args.skinInputFile, args, withGlobal=False)
+ res.append(testStandaloneMesh(args.skinMesh, args))
+ print("\nINFO: testAll skin input file:\n%s" % (PP.pformat(args.skinMesh)))\r
+ \r
+ meshes = []\r
+ for fileName in args.files:\r
+ xxmesh = XXMesh()\r
+ xxmesh.initFromFileMesh(fileName, args)\r
+ meshes.append(xxmesh)\r
+ print("\nINFO: testAll ouput files:\n%s\n" % (PP.pformat(meshes)))\r
+ #test coherence of one by one meshes\r
+ for mesh in meshes:\r
+ res.append(testStandaloneMesh(mesh, args))\r
+ #test coherence of intersections an global numerotation of tetra_hpc_mpi output meshes
+ res.append(testParallelMesh(meshes, args))
+ res.append(testParallelMeshAndSkin(meshes, args))\r
+ res.append(testParallelMeshAndSkinColor(meshes, args))\r
+ return res\r
+
+ \r
+def testStandaloneMesh(mesh, args):
+ """test coherence of one mesh alone"""\r
+ if verbose: print("\nINFO: testStandaloneMesh:\n%s" % PP.pformat(mesh))\r
+ res = []\r
+ res.append(mesh.haveVertsDistinct(args))\r
+ res.append(mesh.areEdgesInTrias(args))\r
+ res.append(mesh.areTriasInTetras(args))\r
+ return res\r
+
+\r
+def testParallelMesh(meshes, args):\r
+ """test intersection and overriding in tetra_hpc_mpi outputs GHS3DPRL_out.00000?.mesh"""\r
+ i = 0\r
+ res = []\r
+ args.intersections = {}\r
+ args.indexglobal = {}\r
+ for m1 in meshes[:-1]:\r
+ i += 1\r
+ for m2 in meshes[i:]:\r
+ res.append(m1.testIntersection(m2, args))\r
+ res.append(m1.testIndexGlobal(m2, args))\r
+ if verbose: \r
+ print("\nINFO: intersections\n%s" % PP.pformat(args.intersections))\r
+ print("\nINFO: indexglobal\n%s" % PP.pformat(args.indexglobal))\r
+ return res\r
+\r
+def testParallelMeshAndSkin(meshes, args):\r
+ """test coherency between input skin and tetra_hpc_mpi outputs GHS3DPRL_out.00000?.mesh"""\r
+ res = []\r
+ if args.skinMesh == None:
+ print("INFO: no skin Mesh for testing intersectionsSkin\n")
+ res = OK + "INFO: no skin Mesh for testing intersectionsSkin"
+ return res
+ nbtriasskin = len(args.skinMesh.trias)\r
+ for m1 in meshes:\r
+ res.append(args.skinMesh.testIntersection(m1, args))\r
+ res.append(args.skinMesh.testIndexGlobal(m1, args))
+
+ #test total Triangles in output parallel meshes vs input skin mesh\r
+ if True:
+ kk = {}
+ nbtriaspara = 0
+ for k in args.intersections.keys():
+ if args.skinMesh.nameFile in k:
+ ll = len(args.intersections[k])
+ if "Triangles intersection" in k:
+ nbtriaspara += ll
+ kk[k] = len(args.intersections[k])\r
+ print("INFO: skin intersections\n%s\n" % PP.pformat(kk))\r
+ if nbtriaspara < nbtriasskin:
+ res.append(KO + " ERROR: problem all skin triangles not in parallel meshes: %i<->%i" % (nbtriasskin, nbtriaspara))\r
+ return res\r
+
+def testParallelMeshAndSkinColor(meshes, args):\r
+ """test coherency between color input skin and tetra_hpc_mpi outputs GHS3DPRL_out.00000?.mesh"""
+ res = []
+ if args.color == True:\r
+ res.append(KO + " ERROR: test color TODO!!!")
+ else:
+ res.append(OK + " WARNING: test color not done")
+ return res\r
+\r
+if __name__ == '__main__':\r
+ parser = AP.ArgumentParser(description='launch test(s) on tetra_hpc_mpi mesh(es)', argument_default=None)\r
+ parser.add_argument(\r
+ '-a', '--testAll', \r
+ help='test all on all meshes',\r
+ action='store_true',\r
+ )\r
+ parser.add_argument(\r
+ '-v', '--verbose', \r
+ help='set verbose, for deep debug',\r
+ action='store_true',\r
+ )\r
+ parser.add_argument(\r
+ '-g', '--globalNumerotation', \r
+ help='read and set files .global, if associated',\r
+ action='store_true',\r
+ )\r
+ parser.add_argument(\r
+ '-c', '--color', \r
+ help='read and test with color',\r
+ action='store_true',\r
+ )\r
+ parser.add_argument(\r
+ '-f', '--files', \r
+ help='launch test(s) on file(s)',\r
+ nargs='*',\r
+ metavar='.../file.mesh'\r
+ )\r
+ parser.add_argument(\r
+ '-s', '--skinInputFile', \r
+ help='launch test(s) on tetra_hpc_mpi input file',\r
+ nargs='?',\r
+ metavar='.../skinInputFile.mesh'\r
+ )\r
+ """\r
+ parser.add_argument(\r
+ '-x', '--xoneargument', \r
+ nargs='?',\r
+ metavar='0|1',\r
+ choices=['0', '1'],\r
+ help='one argument, for example',\r
+ default='0'\r
+ )\r
+ """\r
+ \r
+ \r
+ """
+ args is Namespace, use it as global to store
+ parameters, data, used arrays and results and other...
+ """\r
+ args = parser.parse_args()
+ \r
+ verbose = args.verbose\r
+ if verbose: print("INFO: args:\n%s" % PP.pformat(args))\r
+\r
+ if len(sys.argv) == 1: #no args as --help\r
+ parser.print_help()\r
+ sys.exit(KOSYS)\r
+\r
+ if args.files == None:\r
+ print("\nERROR: Nothing to do: no files\n%s" % PP.pformat(args))\r
+ parser.print_help()\r
+ sys.exit(KOSYS)\r
+ \r
+ if args.testAll: \r
+ result = testAll(args)\r
+ else:\r
+ result = KO\r
+ print("\nERROR: Nothing to do:\n%s" % PP.pformat(args))\r
+ sys.exit(okToSys(result, verbose=True))\r
+ \r
