src/MEDCoupling_Swig/MEDCouplingBasicsTest6.py

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