src/MEDCoupling_Swig/MEDCouplingBasicsTest6.py

   1 #  -*- coding: utf-8 -*-
   2 # Copyright (C) 2017-2019  CEA/DEN, EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License, or (at your option) any later version.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21
  22 import sys
  23 if sys.platform == "win32":
  24     from MEDCouplingCompat import *
  25 else:
  26     from MEDCoupling import *
  27 import unittest
  28 from math import pi,e,sqrt,cos,sin
  29 from datetime import datetime
  30 import rlcompleter,readline # this line has to be here, to ensure a usability of MEDCoupling/MEDLoader. B4 removing it please notify to anthony.geay@edf.fr
  31
  32 class MEDCouplingBasicsTest6(unittest.TestCase):
  33     def testPointSetInvertOrientationOfAllCells(self):
  34         """ Test of inversion of orientation of cells on a different geo types"""
  35         def level1(self):
  36             m=MEDCouplingUMesh("",1)
  37             m.allocateCells()
  38             m.insertNextCell(NORM_SEG2,[3,4])
  39             m.insertNextCell(NORM_SEG2,[13,14])
  40             m.insertNextCell(NORM_SEG3,[5,6,7])
  41             m.insertNextCell(NORM_SEG2,[23,24])
  42             m.insertNextCell(NORM_SEG3,[8,9,10])
  43             ref0=DataArrayInt([0,3,6,10,13,17])
  44             self.assertTrue(m.getNodalConnectivityIndex().isEqual(ref0))
  45             m.invertOrientationOfAllCells()
  46             self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([1,4,3, 1,14,13, 2,7,6,5, 1,24,23, 2,10,9,8])))
  47             self.assertTrue(m.getNodalConnectivityIndex().isEqual(ref0))
  48             pass
  49
  50         def level2(self):
  51             m=MEDCouplingUMesh("",2)
  52             m.allocateCells()
  53             m.insertNextCell(NORM_TRI3,[1,2,3])
  54             m.insertNextCell(NORM_QUAD4,[4,5,6,7])
  55             m.insertNextCell(NORM_POLYGON,[8,9,10,11,12,13])
  56             m.insertNextCell(NORM_TRI6,[14,15,16,17,18,19])
  57             m.insertNextCell(NORM_QUAD8,[20,21,22,23,24,25,26,27])
  58             m.insertNextCell(NORM_QPOLYG,[30,31,32,33,34,35, 36,37,38,39,40,41])
  59             ref0=DataArrayInt([0,4,9,16,23,32,45])
  60             self.assertTrue(m.getNodalConnectivityIndex().isEqual(ref0))
  61             m.invertOrientationOfAllCells()
  62             self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([3,1,3,2, 4,4,7,6,5, 5,8,13,12,11,10,9, 6,14,16,15,19,18,17, 8,20,23,22,21,27,26,25,24, 32,30,35,34,33,32,31,41,40,39,38,37,36])))
  63             self.assertTrue(m.getNodalConnectivityIndex().isEqual(ref0))
  64             pass
  65
  66         def level3(self):
  67             m=MEDCouplingUMesh("",3)
  68             m.allocateCells()
  69             m.insertNextCell(NORM_TETRA4,[1,2,3,4])
  70             m.insertNextCell(NORM_PYRA5,[5,6,7,8,9])
  71             m.insertNextCell(NORM_PENTA6,[10,11,12,13,14,15])
  72             m.insertNextCell(NORM_HEXA8,[20,21,22,23,24,25,26,27])
  73             m.insertNextCell(NORM_TETRA10,[30,31,32,33,34,35,36,37,38,39])
  74             m.insertNextCell(NORM_PYRA13,[40,41,42,43,44,45,46,47,48,49,50,51,52])
  75             m.insertNextCell(NORM_HEXA20,[60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79])
  76             m.insertNextCell(NORM_PENTA15,[80,81,82,83,84,85,86,87,88,89,90,91,92,93,94])
  77             ref0=DataArrayInt([0,5,11,18,27,38,52,73,89])
  78             self.assertTrue(m.getNodalConnectivityIndex().isEqual(ref0))
  79             m.invertOrientationOfAllCells()
  80             self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([14,1,3,2,4, 15,5,8,7,6,9, 16,10,12,11,13,15,14, 18,20,23,22,21,24,27,26,25, 20,30,32,31,33,36,35,34,37,39,38, 23,40,43,42,41,44,48,47,46,45,49,52,51,50, 30,60,63,62,61,64,67,66,65,71,70,69,68,75,74,73,72,76,79,78,77, 25,80,82,81,83,85,84,88,87,86,91,90,89,92,94,93])))
  81             self.assertTrue(m.getNodalConnectivityIndex().isEqual(ref0))
  82             pass
  83
  84         def gtumesh(self):
  85             m=MEDCoupling1SGTUMesh("",NORM_SEG2)
  86             m.setNodalConnectivity(DataArrayInt([1,2,3,4,5,6,7,8]))
  87             self.assertEqual(m.getNumberOfCells(),4)
  88             m2=m.deepCopy()
  89             self.assertTrue(m2.isEqual(m,0.))
  90             m.invertOrientationOfAllCells()
  91             self.assertTrue(not m2.isEqual(m,0.))
  92             m.getNodalConnectivity().isEqual(DataArrayInt([2,1,4,3,6,5,8,7]))
  93             m.invertOrientationOfAllCells()
  94             self.assertTrue(m2.isEqual(m,0.))
  95             #
  96             p=MEDCoupling1DGTUMesh("",NORM_POLYGON)
  97             ref0=DataArrayInt([0,3,7,12])
  98             p.setNodalConnectivity(DataArrayInt([1,2,3, 10,11,12,13, 20,21,22,23,24]),ref0)
  99             p2=p.deepCopy()
 100             self.assertTrue(p2.isEqual(p,0.))
 101             self.assertEqual(p.getNumberOfCells(),3)
 102             p.invertOrientationOfAllCells()
 103             self.assertTrue(not p2.isEqual(p,0.))
 104             self.assertTrue(p.getNodalConnectivityIndex().isEqual(ref0))
 105             self.assertTrue(p.getNodalConnectivity().isEqual(DataArrayInt([1,3,2, 10,13,12,11, 20,24,23,22,21])))
 106             p.invertOrientationOfAllCells()
 107             self.assertTrue(p2.isEqual(p,0.))
 108             pass
 109         level1(self)
 110         level2(self)
 111         level3(self)
 112         gtumesh(self)
 113         pass
 114
 115     def testPenta18_1(self):
 116         arr=DataArrayDouble([
 117             (0.,1.,1.),(0.,0.,1.),(1.,0.,1.),
 118             (0.,1.,0.),(0.,0.,0.),(1.,0.,0.),
 119             (0.,0.5,1.),(0.5,0.,1.),(0.5,0.5,1.),
 120             (0.,0.5,0.),(0.5,0.,0.),(0.5,0.5,0.),
 121             (0.,1.,0.5),(0.,0.,0.5),(1.,0.,0.5),
 122             (0.,0.5,0.5),(0.5,0.,0.5),(0.5,0.5,0.5)])
 123         m=MEDCouplingUMesh("mesh",3)
 124         m.setCoords(arr)
 125         m.allocateCells(1)
 126         m.insertNextCell(NORM_PENTA18,list(range(18)))
 127         m.checkConsistencyLight()
 128         self.assertTrue(m.getMeasureField(True).getArray().isEqual(DataArrayDouble([0.5]),1e-12))
 129         #
 130         f=MEDCouplingFieldDouble(ON_NODES)
 131         f.setMesh(m)
 132         f.setName("FieldOnPenta18")
 133         f.setArray(DataArrayDouble(list(range(18))))
 134         f.checkConsistencyLight()
 135         #
 136         m2,d,di,rd,rdi=m.buildDescendingConnectivity()
 137         self.assertTrue(m2.getNodalConnectivity().isEqual(DataArrayInt([6,0,1,2,6,7,8,6,3,5,4,11,10,9,9,0,3,4,1,12,9,13,6,15,9,1,4,5,2,13,10,14,7,16,9,2,4,5,0,14,11,12,8,17])))
 138         self.assertTrue(m2.getNodalConnectivityIndex().isEqual(DataArrayInt([0,7,14,24,34,44])))
 139         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4])))
 140         self.assertTrue(di.isEqual(DataArrayInt([0,5])))
 141         self.assertTrue(rd.isEqual(DataArrayInt([0,0,0,0,0])))
 142         self.assertTrue(rdi.isEqual(DataArrayInt([0,1,2,3,4,5])))
 143         #
 144         f2=MEDCouplingFieldDouble(ON_NODES)
 145         f2.setMesh(m)
 146         f2.setName("FieldOnPenta18Sub")
 147         f2.setArray(DataArrayDouble(list(range(18))))
 148         f2.checkConsistencyLight()
 149         pass
 150
 151     def testSKLAReplaceDeletePacks(self):
 152         index=DataArrayInt([0,3,5,6,6])
 153         value=DataArrayInt([1,2,3, 2,3, 3  ])
 154         sla=MEDCouplingSkyLineArray(index,value)
 155         idx=DataArrayInt([0,3])
 156         packs=[DataArrayInt([4,5]),DataArrayInt([6,7,8])]
 157         sla.replaceSimplePacks(idx,packs)
 158         self.assertTrue(sla.getIndexArray().isEqual(DataArrayInt([0,2,4,5,8])))
 159         self.assertTrue(sla.getValuesArray().isEqual(DataArrayInt([4,5, 2,3, 3, 6,7,8])))
 160         sla.deleteSimplePacks(idx)
 161         self.assertTrue(sla.getIndexArray().isEqual(DataArrayInt([0,2,3])))
 162         self.assertTrue(sla.getValuesArray().isEqual(DataArrayInt([2,3, 3])))
 163         sla.deleteSimplePack(1)
 164         self.assertTrue(sla.getIndexArray().isEqual(DataArrayInt([0,2])))
 165         self.assertTrue(sla.getValuesArray().isEqual(DataArrayInt([2,3])))
 166         pass
 167
 168     def testDADAsArcOfCircle(self):
 169         d=DataArrayDouble([3.06915124862645,2.1464466094067824,2.85355345827285,2.3620444674400574,2.637955532559882,2.1464467447661937],3,2)
 170         center,radius,ang=d.asArcOfCircle()
 171         self.assertTrue((d-center).magnitude().isUniform(radius,1e-10))
 172         self.assertAlmostEqual(ang,-4.712389294301196,12)
 173         pass
 174
 175     def testDAMaxAbsValue(self):
 176         d=DataArrayDouble([-2,3,1.2,-2.9])
 177         a,b=d.getMaxAbsValue()
 178         self.assertAlmostEqual(a,3.,13)
 179         self.assertEqual(b,1)
 180         a,b=(-d).getMaxAbsValue()
 181         self.assertAlmostEqual(a,-3.,13)
 182         self.assertEqual(b,1)
 183         self.assertAlmostEqual((-d).getMaxAbsValueInArray(),-3.,13)
 184         pass
 185
 186     def testDAIFindIdForEach1(self):
 187         a1=DataArrayInt([17,27,2,10,-4,3,12,27,16])
 188         b1=DataArrayInt([3,16,-4,27,17])
 189         ret=a1.findIdForEach(b1)
 190         self.assertTrue(ret.isEqual(DataArrayInt([5,8,4,7,0])))
 191         self.assertTrue(a1[ret].isEqual(b1))
 192         b2=DataArrayInt([3,16,22,27,17])
 193         self.assertRaises(InterpKernelException,a1.findIdForEach,b2) # 22 not in a1 !
 194         a1.rearrange(3)
 195         self.assertRaises(InterpKernelException,a1.findIdForEach,b1) # a1 is not single component
 196         pass
 197
 198     def testAttractSeg3MidPtsAroundNodes1(self):
 199         """ Test of MEDCouplingUMesh.attractSeg3MidPtsAroundNodes methods """
 200         ptsExpToBeModified=DataArrayInt([95,96,97,98,101,103,104,106,108,110])
 201         eps=1e-12
 202         a=2./3.
 203         b=1./3.
 204         coo=DataArrayDouble([10,0,0,10,10,0,10,0,3.+b,10,0,6.+a,10,10,3.+b,10,10,6.+a,10,3.+b,0,10,6.+a,0,3.+b,0,0,6.+a,0,0,3.+b,10,0,6.+a,10,0,10,3.+b,6.+a,10,6.+a,6.+a,10,3.+b,3.+b,10,6.+a,3.+b,3.+b,0,3.+b,3.+b,0,6.+a,6.+a,0,3.+b,6.+a,0,6.+a,6.+a,10,3.+b,6.+a,10,6.+a,3.+b,10,3.+b,3.+b,10,6.+a,3.+b,3.+b,0,6.+a,3.+b,0,3.+b,6.+a,0,6.+a,6.+a,0,3.+b,3.+b,6.+a,6.+a,3.+b,6.+a,3.+b,6.+a,6.+a,6.+a,6.+a,6.+a,3.+b,3.+b,3.+b,6.+a,3.+b,3.+b,3.+b,6.+a,3.+b,6.+a,6.+a,3.+b,10,0,1.+a,10,0,5.,10,10,1.+a,10,10,5.,10,1.+a,0,10,5.,0,10,8.+b,0,5.,0,0,8.+b,0,0,5.,10,0,8.+b,10,0,10,1.+a,6.+a,10,5.,6.+a,10,8.+b,6.+a,10,1.+a,3.+b,10,3.+b,5.,10,5.,3.+b,10,6.+a,5.,10,8.+b,3.+b,10,3.+b,1.+a,10,6.+a,1.+a,3.+b,0,1.+a,3.+b,0,5.,6.+a,0,1.+a,5.,0,3.+b,6.+a,0,5.,5.,0,6.+a,8.+b,0,3.+b,8.+b,0,6.+a,6.+a,10,1.+a,8.+b,10,3.+b,6.+a,10,5.,8.+b,10,6.+a,3.+b,10,1.+a,5.,10,3.+b,3.+b,10,5.,5.,10,6.+a,3.+b,1.+a,0,5.,3.+b,0,6.+a,1.+a,0,8.+b,3.+b,0,3.+b,5.,0,5.,6.+a,0,6.+a,5.,0,8.+b,6.+a,0,3.+b,8.+b,0,6.+a,8.+b,0,3.+b,1.+a,6.+a,6.+a,1.+a,6.+a,5.,3.+b,6.+a,8.+b,3.+b,6.+a,3.+b,5.,6.+a,6.+a,5.,6.+a,5.,6.+a,6.+a,8.+b,6.+a,6.+a,3.+b,8.+b,6.+a,6.+a,8.+b,6.+a,3.+b,3.+b,5,3.+b,1.+a,3.+b,6.+a,3.+b,5.,6.+a,1.+a,3.+b,5.,3.+b,3.+b,8.+b,3.+b,3.+b,3.+b,6.+a,5.,3.+b,5.,3.+b,6.+a,6.+a,5.,6.+a,5.,3.+b,5.,6.+a,3.+b,8.+b,6.+a,3.+b,3.+b,8.+b,3.+b,6.+a,8.+b,3.+b,3.+b,3.+b,1.+a,6.+a,3.+b,1.+a,3.+b,6.+a,1.+a,6.+a,6.+a,1.+a],111,3)
 205         conn=DataArrayInt([30,17,28,32,16,19,29,33,18,83,93,94,58,84,95,96,61,62,85,97,60,30,19,29,33,18,3,12,14,2,84,95,96,61,47,51,50,37,64,86,98,63,30,28,30,34,32,29,31,35,33,87,99,100,93,88,101,102,95,85,89,103,97,30,29,31,35,33,12,13,15,14,88,101,102,95,48,53,52,51,86,90,104,98,30,30,23,22,34,31,21,20,35,91,71,105,99,92,67,106,101,89,72,70,103,30,31,21,20,35,13,5,4,15,92,67,106,101,49,39,54,53,90,68,66,104,30,16,32,24,8,18,33,25,9,94,107,73,57,96,108,75,59,60,97,74,43,30,18,33,25,9,2,14,6,0,96,108,75,59,50,55,40,36,63,98,76,44,30,32,34,26,24,33,35,27,25,100,109,77,107,102,110,79,108,97,103,78,74,30,33,35,27,25,14,15,7,6,102,110,79,108,52,56,41,55,98,104,80,76,30,34,22,10,26,35,20,11,27,105,69,81,109,106,65,82,110,103,70,45,78,30,35,20,11,27,15,4,1,7,106,65,82,110,54,38,42,56,104,66,46,80])
 206         connI=DataArrayInt([0,21,42,63,84,105,126,147,168,189,210,231,252])
 207         m=MEDCouplingUMesh("mesh",3)
 208         m.setConnectivity(conn,connI,True)
 209         m.setCoords(coo.deepCopy())# deep copy coo because next line is going to modify it, if it works normaly
 210         m.attractSeg3MidPtsAroundNodes(0.1,DataArrayInt([33,35])) # ze call is here !
 211         self.assertTrue(not m.getCoords().isEqual(coo,eps)) # some points have had their position changed...
 212         ptsExpNotToBeModified=ptsExpToBeModified.buildComplement(len(coo))
 213         self.assertTrue(m.getCoords()[ptsExpNotToBeModified].isEqual(coo[ptsExpNotToBeModified],eps))
 214         self.assertTrue((m.getCoords()[ptsExpToBeModified]-coo[ptsExpToBeModified]).magnitude().isUniform(4./3.,1e-12))
 215         ptsPosExp=DataArrayDouble([6.+a,3.+b,3.+a,6.+a,3.,3.+b,6.+b,3.+b,3.+b,7.,3.+b,3.+b,6.+a,6.+a,3.+a,6.+b,6.+a,3.+b,7.,6.+a,3.+b,6.+a,7.,3.+b,6.+a,3.+b,3.,6.+a,6.+a,3.],10,3)
 216         self.assertTrue(m.getCoords()[ptsExpToBeModified].isEqual(ptsPosExp,1e-12))
 217         pass
 218
 219     def testRenumberNodesInConnOpt(self):
 220         """ Test of MEDCouplingPointSet.renumberNodesInConn with map as input coming from DataArrayInt.invertArrayN2O2O2NOptimized
 221         """
 222         m=MEDCouplingUMesh("mesh",2)
 223         m.allocateCells()
 224         m.insertNextCell(NORM_QUAD4,[10000,10002,10001,10003])
 225         coo=DataArrayDouble([(0,0),(1,1),(1,0),(0,1)])
 226         m.setCoords(coo)
 227         m.checkConsistencyLight()
 228         #
 229         d=DataArrayInt([10000,10001,10002,10003])
 230         myMap=d.invertArrayN2O2O2NOptimized()
 231         myMap2=d.giveN2OOptimized()
 232         m.checkConsistencyLight()
 233         #
 234         m.renumberNodesInConn(myMap) # <- test is here for UMesh
 235         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([4,0,2,1,3])))
 236         m.renumberNodesInConn(myMap2) # <- test is here for UMesh
 237         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([4,10000,10002,10001,10003])))
 238         #
 239         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4)
 240         m.setNodalConnectivity(DataArrayInt([10000,10002,10001,10003]))
 241         m.setCoords(coo)
 242         m.checkConsistencyLight()
 243         m.renumberNodesInConn(myMap) # <- test is here for 1SGTUMesh
 244         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([0,2,1,3])))
 245         #
 246         m=MEDCoupling1DGTUMesh("mesh",NORM_POLYGON)
 247         m.setCoords(coo)
 248         m.setNodalConnectivity(DataArrayInt([10000,10002,10001,10003]),DataArrayInt([0,4]))
 249         m.checkConsistencyLight()
 250         m.renumberNodesInConn(myMap) # <- test is here for 1DGTUMesh
 251         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([0,2,1,3])))
 252         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4])))
 253         pass
 254
 255     def testSeg2bGP(self):
 256         """Test of Gauss points on SEG2 using SEG2B style as ref coords
 257         """
 258         coo=DataArrayDouble([[0.,0.,0.],[1.,1.,1.]])
 259         m=MEDCouplingUMesh("mesh",1) ; m.setCoords(coo)
 260         m.allocateCells()
 261         # the cell description is exactly those described in the description of HEXA27 in MED file 3.0.7 documentation
 262         m.insertNextCell(NORM_SEG2,[0,1])
 263         refCoo=[0.,1.]
 264         weights=[0.8,0.1,0.1]
 265         gCoords=[0.2,0.5,0.9]
 266         fGauss=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fGauss.setName("fGauss")
 267         fGauss.setMesh(m)
 268         fGauss.setGaussLocalizationOnType(NORM_SEG2,refCoo,gCoords,weights)
 269         arr=DataArrayDouble(fGauss.getNumberOfTuplesExpected()) ; arr.iota()
 270         fGauss.setArray(arr)
 271         fGauss.checkConsistencyLight()
 272         arrOfDisc=fGauss.getLocalizationOfDiscr()
 273         self.assertTrue(arrOfDisc.isEqual(DataArrayDouble([0.2,0.2,0.2,0.5,0.5,0.5,0.9,0.9,0.9],3,3),1e-12))
 274         pass
 275
 276     def testUMeshGetCellsContainingPtOn2DNonDynQuadraticCells(self):
 277         """getCellsContainingPoint is now dealing curves of quadratic 2D elements.
 278 This test is a mesh containing 2 QUAD8 cells. The input point is located at a special loc.
 279 If true geometry (with curve as edges) is considered the result of getCellsContainingPoint is not the same as if only linear part of cells is considered."""
 280         coords=DataArrayDouble([-0.9428090415820631,0.9428090415820631,-1.06066017177982,1.06066017177982,-1.1785113019775801,1.1785113019775801,-1.2963624321753402,1.2963624321753402,-1.4142135623731,1.41421356237309,-0.7653668647301801,1.8477590650225701,-0.6378057206084831,1.53979922085214,-0.510244576486786,1.23183937668172,-0.701586292669331,1.6937791429373599,-0.574025148547635,1.38581929876693,-0.9259503883660041,1.38578268717091,-0.740760310692803,1.10862614973673,-1.1111404660392,1.66293922460509],13,2)
 281         m=MEDCouplingUMesh("mesh",2)
 282         m.setCoords(coords)
 283         m.allocateCells()
 284         m.insertNextCell(NORM_QUAD8,[4,2,6,5,3,10,8,12])
 285         m.insertNextCell(NORM_QUAD8,[2,0,7,6,1,11,9,10])
 286         #
 287         zePt=DataArrayDouble([-0.85863751450784975,1.4203162316045934],1,2)
 288         a,b=m.getCellsContainingPoints(zePt,1e-12)
 289         self.assertTrue(b.isEqual(DataArrayInt([0,1])))
 290         self.assertTrue(a.isEqual(DataArrayInt([1]))) # <- test is here. 0 if only linear parts are considered.
 291         #
 292         a,b=m.getCellsContainingPointsLinearPartOnlyOnNonDynType(zePt,1e-12)
 293         self.assertTrue(b.isEqual(DataArrayInt([0,1])))
 294         self.assertTrue(a.isEqual(DataArrayInt([0]))) # <- like before
 295         pass
 296
 297     def testComputeIntegralOfSeg2IntoTri3_1(self):
 298         seg2 = [(90453.702115782813, 36372.66281307926), (90457.969790110554, 36373.365088601546)]
 299         tri3 = [(90466.90625, 36376.9375), (90446.5, 36404), (90453.1875, 36365.75)]
 300         a,b=DataArrayDouble.ComputeIntegralOfSeg2IntoTri3(seg2,tri3)
 301         self.assertEqual(len(a),3)
 302         self.assertAlmostEqual(a[0],0.2460689650955214,12)
 303         self.assertAlmostEqual(a[1],0.10875598777133343,12)
 304         self.assertAlmostEqual(a[2],0.6451750471331451,12)
 305         self.assertAlmostEqual(b,4.32507052854159,12)
 306         pass
 307
 308     def testRemoveDegenerated1DCells1(self):
 309         m=MEDCoupling1SGTUMesh("mesh",NORM_SEG2)
 310         conn=DataArrayInt([1,2, 3,4, 5,5, 5,6, 6,6, 6,7, 19,19, 7,8])
 311         m.setNodalConnectivity(conn) # no coords set. It s not a bug. removeDegenerated1DCells doesn't care
 312         m=m.buildUnstructured()
 313         aa=m.getNodalConnectivity().getHiddenCppPointer()
 314         self.assertTrue(m.removeDegenerated1DCells()) # <- test is here
 315         bb=m.getNodalConnectivity().getHiddenCppPointer()
 316         self.assertNotEqual(aa,bb)
 317         expConn=DataArrayInt([1,1,2,1,3,4,1,5,6,1,6,7,1,7,8])
 318         expConnI=DataArrayInt.Range(0,16,3)
 319         self.assertTrue(m.getNodalConnectivity().isEqual(expConn))
 320         self.assertTrue(m.getNodalConnectivityIndex().isEqual(expConnI))
 321         self.assertTrue(not m.removeDegenerated1DCells())
 322         cc=m.getNodalConnectivity().getHiddenCppPointer()
 323         self.assertEqual(bb,cc)
 324         self.assertTrue(m.getNodalConnectivity().isEqual(expConn))
 325         self.assertTrue(m.getNodalConnectivityIndex().isEqual(expConnI))
 326         pass
 327
 328     def testMergeFieldsOnGauss1(self):
 329         mName="mesh"
 330         fieldName="field"
 331         #
 332         _a=0.446948490915965;
 333         _b=0.091576213509771;
 334         _p1=0.11169079483905;
 335         _p2=0.0549758718227661;
 336         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
 337         gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
 338                  2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
 339         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
 340         #
 341         refCoo2=[ -1.,-1., 1.,-1., 1.,1., -1.,1. ]
 342         gsCoo2=[0.1,0.1, 0.2,0.2, 0.5,0.5, 0.6,0.6, 0.7,0.7]
 343         wg2=[0.1,0.2,0.3,0.4,0.5]
 344         #
 345         coo=DataArrayDouble([0,0,1,0,2,0,0,1,1,1,2,1,0,2,1,2,2,2],9,2)
 346         m1=MEDCouplingUMesh(mName,2)
 347         m1.allocateCells() ; m1.setCoords(coo)
 348         m1.insertNextCell(NORM_TRI3,[1,4,2])
 349         m1.insertNextCell(NORM_TRI3,[4,5,2])
 350         m1.insertNextCell(NORM_QUAD4,[4,7,8,5])
 351         f1=MEDCouplingFieldDouble(ON_GAUSS_PT) ; f1.setName(fieldName)
 352         f1.setMesh(m1)
 353         f1.setGaussLocalizationOnType(NORM_TRI3,refCoo1,gsCoo1,wg1)
 354         f1.setGaussLocalizationOnType(NORM_QUAD4,refCoo2,gsCoo2,wg2)
 355         arr=DataArrayDouble(f1.getNumberOfTuplesExpected())
 356         arr.iota()
 357         f1.setArray(arr)
 358         f1.checkConsistencyLight()
 359         #
 360         m2=MEDCouplingUMesh(mName,2)
 361         m2.allocateCells() ; m2.setCoords(coo)
 362         m2.insertNextCell(NORM_QUAD4,[0,3,4,1])
 363         m2.insertNextCell(NORM_QUAD4,[3,6,7,4])
 364         ###################
 365         self.assertTrue(f1.getMesh().getCoords().isEqual(m2.getCoords(),1e-12))
 366         f1.getMesh().setCoords(m2.getCoords())
 367         #
 368         f2=MEDCouplingFieldDouble(ON_GAUSS_PT)
 369         f2.setMesh(m2)
 370         for gt in m2.getAllGeoTypes(): # on recopie les localisation en utilisant f1
 371             glt=f1.getGaussLocalizationIdOfOneType(gt)
 372             gloc=f1.getGaussLocalization(glt)
 373             f2.setGaussLocalizationOnType(gt,gloc.getRefCoords(),gloc.getGaussCoords(),gloc.getWeights())
 374         arr2=DataArrayDouble(f2.getNumberOfTuplesExpected())
 375         arr2[:]=0
 376         f2.setArray(arr2)
 377         f2.checkConsistencyLight()
 378         #
 379         fout1=MEDCouplingFieldDouble.MergeFields([f1,f2])
 380         fout2=MEDCouplingFieldDouble.MergeFields(f1,f2)
 381         #
 382         fOut=MEDCouplingFieldDouble(ON_GAUSS_PT)
 383         mOut=MEDCouplingUMesh.MergeUMeshes([f1.getMesh(),m2])
 384         mOut.setName(f1.getMesh().getName())
 385         fOut.setMesh(mOut)
 386         for gt in f1.getMesh().getAllGeoTypes(): # on recopie les localisation en utilisant f1
 387             glt=f1.getGaussLocalizationIdOfOneType(gt)
 388             gloc=f1.getGaussLocalization(glt)
 389             fOut.setGaussLocalizationOnType(gt,gloc.getRefCoords(),gloc.getGaussCoords(),gloc.getWeights())
 390         fOut.setArray(DataArrayDouble.Aggregate([f1.getArray(),arr2]))
 391         fOut.checkConsistencyLight()
 392         fOut.setName(f1.getName())
 393         fOut.getMesh().setName(f1.getMesh().getName())
 394         #
 395         self.assertTrue(fout1.isEqual(fOut,1e-12,1e-12))
 396         self.assertTrue(fout2.isEqual(fOut,1e-12,1e-12))
 397         pass
 398
 399     pass
 400
 401 if __name__ == '__main__':
 402     unittest.main()