# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2014 CEA/DEN, EDF R&D
+# Copyright (C) 2007-2015 CEA/DEN, 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
self.assertRaises(InterpKernelException,field.setNature,Integral);
self.assertRaises(InterpKernelException,field.setNature,IntegralGlobConstraint);
pass
+
+ def testNatureOperations(self):
+ """ Check nature constraints on field operations """
+ m = MEDCouplingCMesh()
+ m.setCoordsAt(0, DataArrayDouble([1.0,2.0,3.0]))
+ m.setCoordsAt(1, DataArrayDouble([1.0,2.0,3.0]))
+ m = m.buildUnstructured()
+ f1, f2 = MEDCouplingFieldDouble.New(ON_CELLS, NO_TIME), MEDCouplingFieldDouble.New(ON_CELLS, NO_TIME)
+ f1.setNature(Integral)
+ f2.setNature(ConservativeVolumic)
+ self.assertEqual(Integral, f1.getNature())
+ self.assertEqual(ConservativeVolumic, f2.getNature())
+
+ da = DataArrayDouble([1.0,2.0,3.0,4.0])
+ f1.setMesh(m); f2.setMesh(m)
+ f1.setArray(da); f2.setArray(da.deepCpy())
+ # All this should complain about nature:
+ self.assertRaises(InterpKernelException, f1.__add__, f2)
+ self.assertRaises(InterpKernelException, f1.__iadd__, f2)
+ self.assertRaises(InterpKernelException, f1.__sub__, f2)
+ self.assertRaises(InterpKernelException, f1.__isub__, f2)
+ self.assertRaises(InterpKernelException, f1.__radd__, f2)
+ self.assertRaises(InterpKernelException, f1.__rsub__, f2)
+ self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.AddFields, f1, f2)
+ self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.SubstractFields, f1, f2)
+ self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.MaxFields, f1, f2)
+ self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.MinFields, f1, f2)
+ # Not those ones:
+ f3 = MEDCouplingFieldDouble.MultiplyFields(f1,f2)
+ self.assertEqual(NoNature, f3.getNature())
+ f3 = f1*f2
+ self.assertEqual(NoNature, f3.getNature())
+ f1Tmp = f1.deepCpy(); f1Tmp.setMesh(m); f1Tmp *= f2
+ self.assertEqual(NoNature, f1Tmp.getNature())
+ f3 = MEDCouplingFieldDouble.DivideFields(f1,f2)
+ self.assertEqual(NoNature, f3.getNature())
+ f3 = f1/f2
+ self.assertEqual(NoNature, f3.getNature())
+ f1Tmp = f1.deepCpy(); f1Tmp.setMesh(m); f1Tmp /= f2
+ self.assertEqual(NoNature, f1Tmp.getNature())
+# f3 = MEDCouplingFieldDouble.PowFields(f1,f2)
+# self.assertEqual(NoNature, f3.getNature())
+ f3 = f1**f2
+ self.assertEqual(NoNature, f3.getNature())
+ f1Tmp = f1.deepCpy(); f1Tmp.setMesh(m); f1Tmp **= f2
+ self.assertEqual(NoNature, f1Tmp.getNature())
+ f3 = MEDCouplingFieldDouble.DotFields(f1,f2)
+ self.assertEqual(NoNature, f3.getNature())
+ f3 = f1.dot(f2)
+ self.assertEqual(NoNature, f3.getNature())
+
+ da = DataArrayDouble.Meld([da, da, da])
+ f1.setArray(da); f2.setArray(da.deepCpy())
+ f3 = MEDCouplingFieldDouble.CrossProductFields(f1,f2)
+ self.assertEqual(NoNature, f3.getNature())
+ f3 = f1.crossProduct(f2)
def testBuildSubMeshData(self):
targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1()
center=[0.,0.,0.]
vector=[0.,1.,0.]
m2.rotate(center,vector,-pi/2.);
+ m1.zipCoords()
m3=m1.buildExtrudedMesh(m2,0);
expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
rexpected1=[3, 0, 2, 1, 14, 5, 4, 6, 9, 11, 7, 8, 10, 13, 12]
self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],16);
pass
m5=m4.build3DUnstructuredMesh();
+ m5.zipCoords()
self.assertTrue(m5.isEqual(m3,1e-12));
f=m5.getMeasureField(True);
f.setMesh(m4)
self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
pass
pass
+
+ def testSwig2CheckDeepEquivalWith1(self):
+ eps = 1.0e-8
+ mcart = MEDCouplingCMesh()
+ mcart.setCoordsAt(0, DataArrayDouble([0.0,1.5,2.0]))
+ mcart.setCoordsAt(1, DataArrayDouble([1.0,2.5,3.0,4.0]))
+ m = mcart.buildUnstructured()
+ m2 = m[1:m.getNumberOfCells()]
+ self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 0, eps)
+ self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 1, eps)
+ self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 2, eps)
+ pass
+
+ def testSwig2CheckDeepEquivalWith2(self):
+ eps = 1.0e-8
+ m = MEDCouplingUMesh("tst", 2)
+ m.setCoords(DataArrayDouble([], 0,2))
+ m.setConnectivity(DataArrayInt([]), DataArrayInt([0]))
+ m2 = m.deepCpy()
+ m.checkDeepEquivalWith(m2, 0, eps) # Should not raise!
+ pass
def testCopyTinyStringsFromOnFields(self):
m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
f.setArray(arr)
f.checkCoherency()
self.assertTrue(DataArrayDouble(f.integral(False)).isEqual(DataArrayDouble([-211.66121638700983,-4863.9563007698835]),1e-11))
- self.assertTrue(DataArrayDouble(f.getWeightedAverageValue()).isEqual(DataArrayDouble([45.496085813113595,1045.496085813114]),1e-11))
+ self.assertTrue(DataArrayDouble(f.getWeightedAverageValue()).isEqual(DataArrayDouble([45.4960858131136,1045.496085813114]),1e-11))
self.assertTrue(DataArrayDouble(f.normL1()).isEqual(DataArrayDouble([45.49608581311362,1045.496085813114]),1e-11))
self.assertTrue(DataArrayDouble(f.normL2()).isEqual(DataArrayDouble([58.16846378340898,1046.1241521947334]),1e-11))
pass
self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30])))
coo0=DataArrayDouble([(0,0,0),(1,0,0),(2,0,0),(0,1,0),(1,1,0),(2,1,0),(0,2,0),(1,2,0),(2,2,0),(0,3,0),(1,3,0),(2,3,0)])
self.assertTrue(mu.getCoords().isEqual(coo0,1e-12))
- mu.writeVTK("tutu.vtu")
#
m=MEDCouplingCMesh()
arrX=DataArrayDouble(3) ; arrX.iota()
m.colinearize2D(1e-12)
m.checkCoherency2()
self.assertEqual(refPtr,m.getCoords().getHiddenCppPointer())
- self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([5,0,2,3,4])))
+ self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([NORM_POLYGON,0,2,3,4])))
self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5])))
pass
+ def testSwig2Colinearize2D3(self):
+ """ colinearize was too agressive, potentially producing cells with one edge """
+ # Flat polygon with 3 edges - nothing should happen (min number of edges for a linear polyg)
+ coo = DataArrayDouble([0.0,0.0, 2.0,0.0, 1.5,0.0, 1.0,0.0, 0.5,0.0], 5,2)
+ m = MEDCouplingUMesh("m", 2)
+ c, cI = [DataArrayInt(l) for l in [[NORM_POLYGON, 0,1,2], [0,4]] ]
+ m.setCoords(coo); m.setConnectivity(c, cI)
+ m.colinearize2D(1e-10)
+ m.checkCoherency2()
+ self.assertEqual(c.getValues(), m.getNodalConnectivity().getValues())
+ self.assertEqual(cI.getValues(), m.getNodalConnectivityIndex().getValues())
+
+ # Flat quad polygon, 2 edges - nothing should happen (min number of edges for a quad polyg)
+ m = MEDCouplingUMesh("m", 2)
+ c, cI = [DataArrayInt(l) for l in [[NORM_QPOLYG, 0,1, 2,3], [0,5]] ]
+ m.setCoords(coo); m.setConnectivity(c, cI)
+ m.colinearize2D(1e-10)
+ m.checkCoherency2()
+ self.assertEqual(c.getValues(), m.getNodalConnectivity().getValues())
+ self.assertEqual(cI.getValues(), m.getNodalConnectivityIndex().getValues())
+
+ # Flat polygon, 4 edges - one reduction should happen
+ m = MEDCouplingUMesh("m", 2)
+ c, cI = [DataArrayInt(l) for l in [[NORM_POLYGON, 0,1,2,3], [0,5]] ]
+ m.setCoords(coo); m.setConnectivity(c, cI)
+ m.colinearize2D(1e-10)
+ m.checkCoherency2()
+ self.assertEqual([NORM_POLYGON, 3,1,2], m.getNodalConnectivity().getValues())
+ self.assertEqual([0,4], m.getNodalConnectivityIndex().getValues())
+
+ # Flat quad polygon, 3 edges - one reduction expected
+ m = MEDCouplingUMesh("m", 2)
+ c, cI = [DataArrayInt(l) for l in [[NORM_QPOLYG, 0,1,3, 3,2,4], [0,7]] ]
+ m.setCoords(coo); m.setConnectivity(c, cI)
+ m.colinearize2D(1e-10)
+ m.checkCoherency2()
+ self.assertEqual([NORM_QPOLYG, 3,1, 5,2], m.getNodalConnectivity().getValues())
+ self.assertTrue( m.getCoords()[5].isEqual( DataArrayDouble([(1.5,0.0)]), 1.0e-12 ) )
+ self.assertEqual([0,5], m.getNodalConnectivityIndex().getValues())
+
+ # Now an actual (neutronic) case: circle made of 4 SEG3. Should be reduced to 2 SEG3
+ m = MEDCouplingDataForTest.buildCircle2(0.0, 0.0, 1.0)
+ c, cI = [DataArrayInt(l) for l in [[NORM_QPOLYG, 7,5,3,1, 6,4,2,0], [0,9]] ]
+ m.colinearize2D(1e-10)
+ m.checkCoherency2()
+ self.assertEqual([NORM_QPOLYG, 3,5, 8,4], m.getNodalConnectivity().getValues())
+ self.assertTrue( m.getCoords()[8].isEqual( DataArrayDouble([(1.0,0.0)]), 1.0e-12 ) )
+ self.assertEqual([0,5], m.getNodalConnectivityIndex().getValues())
+
def testSwig2CheckAndPreparePermutation2(self):
a=DataArrayInt([10003,9999999,5,67])
self.assertTrue(DataArrayInt.CheckAndPreparePermutation(a).isEqual(DataArrayInt([2,3,0,1])))
r=it.next()
self.assertEqual(len(r),3)
j,k,l=r
- assert(inp.isEqual(DataArrayDouble([a,b,c,d,e,f,g,h,i,j,k,l],4,3),1e-12))
+ self.assertTrue(inp.isEqual(DataArrayDouble([a,b,c,d,e,f,g,h,i,j,k,l],4,3),1e-12))
########
inp=DataArrayInt([(1,2,3),(4,5,6),(7,8,9),(10,11,12)])
it=inp.__iter__()
r=it.next()
self.assertEqual(len(r),3)
j,k,l=r
- assert(inp.isEqual(DataArrayInt([a,b,c,d,e,f,g,h,i,j,k,l],4,3)))
+ self.assertTrue(inp.isEqual(DataArrayInt([a,b,c,d,e,f,g,h,i,j,k,l],4,3)))
pass
def testSwig2IMesh1(self):
self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([1,0,3,4,2,1,4,5,4,3,6,7,5,4,7,8,7,6,9,10,8,7,10,11])))
pass
+ def testSwig1GetValuesAsTuple1(self):
+ d=DataArrayDouble()
+ self.assertEqual(d.getValues(),[])
+ self.assertEqual(d.getValuesAsTuple(),[])
+ d=DataArrayDouble(24) ; d.iota() ; d.rearrange(3)
+ self.assertEqual(d.getValues(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,20.,21.,22.,23.])
+ self.assertEqual(d.getValuesAsTuple(),[(0.,1.,2.0),(3.,4.,5.0),(6.,7.,8.0),(9.,10.,11.0),(12.,13.,14.0),(15.,16.,17.0),(18.,19.,20.0),(21.,22.,23.)])
+ d=DataArrayInt()
+ self.assertEqual(d.getValues(),[])
+ self.assertEqual(d.getValuesAsTuple(),[])
+ d=DataArrayInt(24) ; d.iota() ; d.rearrange(3)
+ self.assertEqual(d.getValues(),[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23])
+ self.assertEqual(d.getValuesAsTuple(),[(0,1,2),(3,4,5),(6,7,8),(9,10,11),(12,13,14),(15,16,17),(18,19,20),(21,22,23)])
+ pass
+
def testSwig2AMR1(self):
self.assertEqual((1,3,12),MEDCouplingStructuredMesh.GetSplitVectFromStruct([3,4,5]))
self.assertEqual((3,2),MEDCouplingStructuredMesh.GetDimensionsFromCompactFrmt([(1,4),(2,4)]))
ids=b.getIdsInRange(0.4,0.7)
f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(im) ; f.setName("toto") ; arr=DataArrayDouble(im.getNumberOfCells()) ; arr[:]=0. ; arr[ids]=1. ; f.setArray(arr)
# f.write("test.vti")
- amr=MEDCouplingCartesianAMRMesh("mesh",2,[51,51],[0.,0.],[0.04,0.04])
+ amr=MEDCouplingCartesianAMRMesh(MEDCouplingIMesh("mesh",2,[51,51],[0.,0.],[0.04,0.04]))
arr2=DataArrayByte(im.getNumberOfCells()) ; arr2[:]=0 ; arr2[ids]=1
- bso=BoxSplittingOptions() ; bso.setEffeciency(0.8) ; bso.setEffeciencySnd(0.8) ; bso.setMaxCells(1000) ; bso.setMinCellDirection(3)
+ bso=BoxSplittingOptions() ; bso.setEfficiencyGoal(0.5); bso.setEfficiencyThreshold(0.8) ; bso.setMaximumNbOfCellsInPatch(3000) ; bso.setMinimumPatchLength(6) ; bso.setMaximumPatchLength(11)
amr.createPatchesFromCriterion(bso,arr2,[2,2])
- self.assertEqual(18,amr.getNumberOfPatches())
- exp0=[[(8,14),(19,38)],[(19,31),(8,17)],[(19,31),(33,42)],[(10,14),(12,16)],[(9,14),(16,19)],[(14,19),(9,19)],[(14,17),(19,22)],[(14,19),(31,41)],[(36,42),(19,38)],[(14,15),(22,28)],[(14,17),(28,31)],[(31,36),(9,19)],[(33,36),(19,22)],[(31,36),(31,41)],[(36,40),(12,16)],[(36,41),(16,19)],[(35,36),(22,28)],[(33,36),(28,31)]]
+ m=amr.getImageMesh() ; m=m.buildUnstructured() ; m.changeSpaceDimension(3,1.)
+ self.assertEqual(12,amr.getNumberOfPatches())
+ exp0=[[(9,19),(9,19)],[(9,19),(31,41)],[(31,41),(9,19)],[(8,17),(19,25)],[(8,17),(25,31)],[(19,25),(8,17)],[(25,31),(8,17)],[(19,25),(33,42)],[(25,31),(33,42)],[(31,41),(31,41)],[(33,42),(19,25)],[(33,42),(25,31)]]
for i,bltr in enumerate(exp0):
self.assertEqual(amr[i].getBLTRRange(),bltr)
pass
- m=amr.buildMeshFromPatchEnvelop()
- self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([1,0,2,3,5,4,6,7,9,8,10,11,13,12,14,15,17,16,18,19,21,20,22,23,25,24,26,27,29,28,30,31,33,32,34,35,37,36,38,39,41,40,42,43,45,44,46,47,49,48,50,51,53,52,54,55,57,56,58,59,61,60,62,63,65,64,66,67,69,68,70,71])))
- self.assertTrue(m.getCoords().isEqualWithoutConsideringStr(DataArrayDouble([0.32,0.76,0.56,0.76,0.32,1.52,0.56,1.52,0.76,0.32,1.24,0.32,0.76,0.68,1.24,0.68,0.76,1.32,1.24,1.32,0.76,1.68,1.24,1.68,0.4,0.48,0.56,0.48,0.4,0.64,0.56,0.64,0.36,0.64,0.56,0.64,0.36,0.76,0.56,0.76,0.56,0.36,0.76,0.36,0.56,0.76,0.76,0.76,0.56,0.76,0.68,0.76,0.56,0.88,0.68,0.88,0.56,1.24,0.76,1.24,0.56,1.64,0.76,1.64,1.44,0.76,1.68,0.76,1.44,1.52,1.68,1.52,0.56,0.88,0.6,0.88,0.56,1.12,0.6,1.12,0.56,1.12,0.68,1.12,0.56,1.24,0.68,1.24,1.24,0.36,1.44,0.36,1.24,0.76,1.44,0.76,1.32,0.76,1.44,0.76,1.32,0.88,1.44,0.88,1.24,1.24,1.44,1.24,1.24,1.64,1.44,1.64,1.44,0.48,1.6,0.48,1.44,0.64,1.6,0.64,1.44,0.64,1.64,0.64,1.44,0.76,1.64,0.76,1.4,0.88,1.44,0.88,1.4,1.12,1.44,1.12,1.32,1.12,1.44,1.12,1.32,1.24,1.44,1.24],72,2),1e-12))
+ self.assertAlmostEqual(0.666666666667,amr[3].getMesh().getImageMesh().computeSquareness(),12)
#
self.assertEqual(MEDCouplingStructuredMesh.ChangeReferenceToGlobalOfCompactFrmt([(8,32),(4,17)],[(0,24),(2,12)]),[(8,32),(6,16)])
self.assertEqual(MEDCouplingStructuredMesh.ChangeReferenceFromGlobalOfCompactFrmt([(8,32),(4,17)],[(8,32),(6,16)]),[(0,24),(2,12)])
fine=DataArrayDouble((3*4+2*1)*(2*4+2*1)) ; fine.iota(1000) #X=3,Y=2 refined by 4
MEDCouplingIMesh.SpreadCoarseToFineGhost(coarse,[5,7],fine,[(1,4),(2,4)],[4,4],1)
self.assertTrue(fine.isEqual(DataArrayDouble([15.,16.,16.,16.,16.,17.,17.,17.,17.,18.,18.,18.,18.,19.,22.,23.,23.,23.,23.,24.,24.,24.,24.,25.,25.,25.,25.,26.,22.,23.,23.,23.,23.,24.,24.,24.,24.,25.,25.,25.,25.,26.,22.,23.,23.,23.,23.,24.,24.,24.,24.,25.,25.,25.,25.,26.,22.,23.,23.,23.,23.,24.,24.,24.,24.,25.,25.,25.,25.,26.,29.,30.,30.,30.,30.,31.,31.,31.,31.,32.,32.,32.,32.,33.,29.,30.,30.,30.,30.,31.,31.,31.,31.,32.,32.,32.,32.,33.,29.,30.,30.,30.,30.,31.,31.,31.,31.,32.,32.,32.,32.,33.,29.,30.,30.,30.,30.,31.,31.,31.,31.,32.,32.,32.,32.,33.,36.,37.,37.,37.,37.,38.,38.,38.,38.,39.,39.,39.,39.,40.]),1e-12))
- f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(MEDCouplingIMesh("",2,DataArrayInt([8,10]),[0.,0.],DataArrayDouble((1.,1.)))) ; f.setArray(coarse) ; f.setName("tutu") ; f.checkCoherency() ; f.writeVTK("coarse.vti")
+ f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(MEDCouplingIMesh("",2,DataArrayInt([8,10]),[0.,0.],DataArrayDouble((1.,1.)))) ; f.setArray(coarse) ; f.setName("tutu") ; f.checkCoherency()
coarse.iota(-1000)
fine2=DataArrayDouble.Meld(fine,3*fine) ; coarse2=DataArrayDouble.Meld(coarse,3*coarse)
MEDCouplingIMesh.CondenseFineToCoarseGhost([5,7],fine,[(1,4),(2,4)],[4,4],coarse,1)
MEDCouplingIMesh.CondenseFineToCoarseGhost([5,7],fine2,[(1,4),(2,4)],[4,4],coarse2,1)
- f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(MEDCouplingIMesh("",2,DataArrayInt([8,10]),[0.,0.],DataArrayDouble((1.,1.)))) ; f.setArray(coarse) ; f.setName("tutu") ; f.checkCoherency() ; f.writeVTK("coarse.vti")
+ f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(MEDCouplingIMesh("",2,DataArrayInt([8,10]),[0.,0.],DataArrayDouble((1.,1.)))) ; f.setArray(coarse) ; f.setName("tutu") ; f.checkCoherency()
coarseExp=DataArrayDouble([-1000.,-999.,-998.,-997.,-996.,-995.,-994.,-993.,-992.,-991.,-990.,-989.,-988.,-987.,-986.,-985.,-984.,-983.,-982.,-981.,-980.,-979.,-978.,368.,384.,400.,-974.,-973.,-972.,-971.,480.,496.,512.,-967.,-966.,-965.,-964.,-963.,-962.,-961.,-960.,-959.,-958.,-957.,-956.,-955.,-954.,-953.,-952.,-951.,-950.,-949.,-948.,-947.,-946.,-945.,-944.,-943.,-942.,-941.,-940.,-939.,-938.])
self.assertTrue(coarse.isEqual(coarseExp,1e-12))
self.assertTrue(coarse2[:,0].isEqual(coarseExp,1e-12))
amr[0].addPatch([(10,12),(5,8)],[2,2])
amr[1].addPatch([(0,1),(0,5)],[2,2])
amr[2].addPatch([(3,4),(0,3)],[2,2])
+ m=amr.buildMeshFromPatchEnvelop()
+ self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([1,0,2,3,5,4,6,7,9,8,10,11])))
+ self.assertTrue(m.getCoords().isEqualWithoutConsideringStr(DataArrayDouble([1.,2.,4.,2.,1.,4.,4.,4.,4.,3.,5.,3.,4.,5.,5.,5.,0.,4.,1.,4.,0.,6.,1.,6.],12,2),1e-12))
self.assertEqual(3,amr.getMaxNumberOfLevelsRelativeToThis())
att=MEDCouplingAMRAttribute(amr,[("Field",["X"])],ghostSz)
att.alloc()
# the test is here ! To be called after iteration with no remesh
att.synchronizeAllGhostZones()
f=att.buildCellFieldOnWithGhost(amr,"Field") ; f.checkCoherency()
- ftmp=att.buildCellFieldOnWithoutGhost(amr,"Field") ; ftmp.checkCoherency() ; self.assertTrue(ftmp.getArray().isEqualWithoutConsideringStr(DataArrayDouble([8.1,9.1,10.1,11.1,12.1,15.1,16.1,17.1,18.1,19.1,22.1,23.1,24.1,25.1,26.1,29.1,30.1,31.1,32.1,33.1,36.1,37.1,38.1,39.1,40.1,43.1,44.1,45.1,46.1,47.1]),1e-12)) ; ftmp.writeVTK("ftmp.vti")
+ ftmp=att.buildCellFieldOnWithoutGhost(amr,"Field") ; ftmp.checkCoherency() ; self.assertTrue(ftmp.getArray().isEqualWithoutConsideringStr(DataArrayDouble([8.1,9.1,10.1,11.1,12.1,15.1,16.1,17.1,18.1,19.1,22.1,23.1,24.1,25.1,26.1,29.1,30.1,31.1,32.1,33.1,36.1,37.1,38.1,39.1,40.1,43.1,44.1,45.1,46.1,47.1]),1e-12))
f0=att.buildCellFieldOnWithGhost(amr[0].getMesh(),"Field")
f1=att.buildCellFieldOnWithGhost(amr[1].getMesh(),"Field")
f2=att.buildCellFieldOnWithGhost(amr[2].getMesh(),"Field")
d20.iota() ; d20+=0.7
# the test is here ! To be called after iteration with no remesh
att.synchronizeAllGhostZones()
- f=att.buildCellFieldOnWithGhost(amr,"Field") ; f.writeVTK("ff.vti")
- f0=att.buildCellFieldOnWithGhost(amr[0].getMesh(),"Field") ; f0.writeVTK("f0.vti")
- f1=att.buildCellFieldOnWithGhost(amr[1].getMesh(),"Field") ; f1.writeVTK("f1.vti")
- f2=att.buildCellFieldOnWithGhost(amr[2].getMesh(),"Field") ; f2.writeVTK("f2.vti")
- f00=att.buildCellFieldOnWithGhost(amr[0][0].getMesh(),"Field") ; f00.writeVTK("f00.vti")
- f10=att.buildCellFieldOnWithGhost(amr[1][0].getMesh(),"Field") ; f10.writeVTK("f10.vti")
- f20=att.buildCellFieldOnWithGhost(amr[2][0].getMesh(),"Field") ; f20.writeVTK("f20.vti")
+ f=att.buildCellFieldOnWithGhost(amr,"Field")
+ f0=att.buildCellFieldOnWithGhost(amr[0].getMesh(),"Field")
+ f1=att.buildCellFieldOnWithGhost(amr[1].getMesh(),"Field")
+ f2=att.buildCellFieldOnWithGhost(amr[2].getMesh(),"Field")
+ f00=att.buildCellFieldOnWithGhost(amr[0][0].getMesh(),"Field")
+ f10=att.buildCellFieldOnWithGhost(amr[1][0].getMesh(),"Field")
+ f20=att.buildCellFieldOnWithGhost(amr[2][0].getMesh(),"Field")
self.assertTrue(f0.getArray().isEqualWithoutConsideringStr(DataArrayDouble([29.1,29.1,30.1,30.1,30.1,30.1,31.1,31.1,31.1,31.1,32.1,32.1,32.1,32.1,33.1,33.1,29.1,29.1,30.1,30.1,30.1,30.1,31.1,31.1,31.1,31.1,32.1,32.1,32.1,32.1,33.1,33.1,38.1,38.1,34.2,35.2,36.2,37.2,38.2,39.2,40.2,41.2,42.2,43.2,44.2,45.2,42.1,42.1,38.1,38.1,50.2,51.2,52.2,53.2,54.2,55.2,56.2,57.2,58.2,59.2,60.2,61.2,42.1,42.1,38.1,38.1,66.2,67.2,68.2,69.2,70.2,71.2,72.2,73.2,74.2,75.2,76.2,77.2,42.1,42.1,38.1,38.1,82.2,83.2,84.2,85.2,86.2,87.2,88.2,89.2,90.2,91.2,92.2,93.2,42.1,42.1,47.1,47.1,98.2,99.2,100.2,101.2,102.2,103.2,104.2,105.2,106.2,107.2,108.2,109.2,18.3,19.3,47.1,47.1,114.2,115.2,116.2,117.2,118.2,119.2,120.2,121.2,122.2,123.2,124.2,125.2,26.3,27.3,47.1,47.1,130.2,131.2,132.2,133.2,134.2,135.2,136.2,137.2,138.2,139.2,140.2,141.2,34.3,35.3,47.1,47.1,146.2,147.2,148.2,149.2,150.2,151.2,152.2,153.2,154.2,155.2,156.2,157.2,42.3,43.3,20.4,21.4,57.1,57.1,57.1,57.1,58.1,58.1,58.1,58.1,59.1,59.1,59.1,59.1,50.3,51.3,28.4,29.4,57.1,57.1,57.1,57.1,58.1,58.1,58.1,58.1,59.1,59.1,59.1,59.1,58.3,59.3]),1e-12))
self.assertTrue(f1.getArray().isEqualWithoutConsideringStr(DataArrayDouble([76.2,77.2,42.1,42.1,42.1,42.1,43.1,43.1,92.2,93.2,42.1,42.1,42.1,42.1,43.1,43.1,108.2,109.2,18.3,19.3,20.3,21.3,52.1,52.1,124.2,125.2,26.3,27.3,28.3,29.3,52.1,52.1,140.2,141.2,34.3,35.3,36.3,37.3,52.1,52.1,156.2,157.2,42.3,43.3,44.3,45.3,52.1,52.1,59.1,59.1,50.3,51.3,52.3,53.3,61.1,61.1,59.1,59.1,58.3,59.3,60.3,61.3,61.1,61.1,59.1,59.1,66.3,67.3,68.3,69.3,61.1,61.1,59.1,59.1,74.3,75.3,76.3,77.3,61.1,61.1,68.1,68.1,69.1,69.1,69.1,69.1,70.1,70.1,68.1,68.1,69.1,69.1,69.1,69.1,70.1,70.1]),1e-12))
self.assertTrue(f2.getArray().isEqualWithoutConsideringStr(DataArrayDouble([46.1,46.1,47.1,47.1,47.1,47.1,130.2,131.2,46.1,46.1,47.1,47.1,47.1,47.1,146.2,147.2,55.1,55.1,18.4,19.4,20.4,21.4,57.1,57.1,55.1,55.1,26.4,27.4,28.4,29.4,57.1,57.1,55.1,55.1,34.4,35.4,36.4,37.4,57.1,57.1,55.1,55.1,42.4,43.4,44.4,45.4,57.1,57.1,64.1,64.1,50.4,51.4,52.4,53.4,66.1,66.1,64.1,64.1,58.4,59.4,60.4,61.4,66.1,66.1,64.1,64.1,66.4,67.4,68.4,69.4,66.1,66.1,64.1,64.1,74.4,75.4,76.4,77.4,66.1,66.1,73.1,73.1,74.1,74.1,74.1,74.1,75.1,75.1,73.1,73.1,74.1,74.1,74.1,74.1,75.1,75.1]),1e-12))
amr[1].addPatch([(4,7),(0,3)],[3,3])
amr[1].addPatch([(4,7),(3,6)],[3,3])
amr.addPatch([(0,3),(6,10)],[2,2])
+ self.assertEqual(([(30,39),(27,36)],[6,6]),amr[1][3].getMesh().positionRelativeToGodFather())
+ self.assertEqual(([(6,16),(6,12)],[2,2]),amr[1].getMesh().positionRelativeToGodFather())
+ self.assertTrue(not MEDCouplingStructuredMesh.AreRangesIntersect([(30,39),(27,36)],[(6,16),(6,12)]))
+ self.assertTrue(MEDCouplingStructuredMesh.AreRangesIntersect([(30,39),(27,36)],[(28,32),(35,37)]))
+ da=DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.])
+ MEDCouplingStructuredMesh.AssignPartOfFieldOfDoubleUsing([3,4],da,[(1,3),(2,3)],DataArrayDouble([7.7,8.8]))
+ self.assertTrue(da.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.7,8.8,9.,10.,11.]),1e-12))
att=MEDCouplingAMRAttribute(amr,[("YY",1)],szGhost)
att.spillNatures([ConservativeVolumic])
att.alloc()
for pos in [(),(0,),(1,),(2,)]:
self.assertTrue(att5.getFieldOn(att5.getMyGodFather().getMeshAtPosition(pos),"YY").isEqual(att6.getFieldOn(att6.getMyGodFather().getMeshAtPosition(pos),"YY"),1e-12))
pass
- att5.buildCellFieldOnWithGhost(att5.getMyGodFather().getMeshAtPosition((0,0)),"YY").writeVTK("mesh00.vti")
+ att5.buildCellFieldOnWithGhost(att5.getMyGodFather().getMeshAtPosition((0,0)),"YY")
exp19=DataArrayDouble([57.02,57.02,58.02,58.02,58.02,59.02,59.02,59.02,60.02,60.02,60.02,61.02,61.02,61.02,62.02,62.02,62.02,63.02,63.02,63.02,64.02,64.02,64.02,65.02,65.02,65.02,66.02,66.02,66.02,67.02,67.02,67.02,68.02,68.02,57.02,57.02,58.02,58.02,58.02,59.02,59.02,59.02,60.02,60.02,60.02,61.02,61.02,61.02,62.02,62.02,62.02,63.02,63.02,63.02,64.02,64.02,64.02,65.02,65.02,65.02,66.02,66.02,66.02,67.02,67.02,67.02,68.02,68.02,71.02,71.02,70.04,71.04,72.04,73.04,74.04,75.04,76.04,77.04,78.04,79.04,80.04,81.04,82.04,83.04,84.04,85.04,86.04,87.04,88.04,89.04,90.04,91.04,92.04,93.04,94.04,95.04,96.04,97.04,98.04,99.04,82.02,82.02,71.02,71.02,104.04,105.04,106.04,107.04,108.04,109.04,110.04,111.04,112.04,113.04,114.04,115.04,116.04,117.04,118.04,119.04,120.04,121.04,122.04,123.04,124.04,125.04,126.04,127.04,128.04,129.04,130.04,131.04,132.04,133.04,82.02,82.02,71.02,71.02,138.04,139.04,140.04,141.04,142.04,143.04,144.04,145.04,146.04,147.04,148.04,149.04,150.04,151.04,152.04,153.04,154.04,155.04,156.04,157.04,158.04,159.04,160.04,161.04,162.04,163.04,164.04,165.04,166.04,167.04,82.02,82.02,85.02,85.02,172.04,173.04,174.04,175.04,176.04,177.04,178.04,179.04,180.04,181.04,182.04,183.04,184.04,185.04,186.04,187.04,188.04,189.04,190.04,191.04,192.04,193.04,194.04,195.04,196.04,197.04,198.04,199.04,200.04,201.04,96.02,96.02,85.02,85.02,206.04,207.04,208.04,209.04,210.04,211.04,212.04,213.04,214.04,215.04,216.04,217.04,218.04,219.04,220.04,221.04,222.04,223.04,224.04,225.04,226.04,227.04,228.04,229.04,230.04,231.04,232.04,233.04,234.04,235.04,96.02,96.02,85.02,85.02,240.04,241.04,242.04,243.04,244.04,245.04,246.04,247.04,248.04,249.04,250.04,251.04,252.04,253.04,254.04,255.04,256.04,257.04,258.04,259.04,260.04,261.04,262.04,263.04,264.04,265.04,266.04,267.04,268.04,269.04,96.02,96.02,99.02,99.02,274.04,275.04,276.04,277.04,278.04,279.04,280.04,281.04,282.04,283.04,284.04,285.04,286.04,287.04,288.04,289.04,290.04,291.04,292.04,293.04,294.04,295.04,296.04,297.04,298.04,299.04,300.04,301.04,302.04,303.04,110.02,110.02,99.02,99.02,308.04,309.04,310.04,311.04,312.04,313.04,314.04,315.04,316.04,317.04,318.04,319.04,320.04,321.04,322.04,323.04,324.04,325.04,326.04,327.04,328.04,329.04,330.04,331.04,332.04,333.04,334.04,335.04,336.04,337.04,110.02,110.02,99.02,99.02,342.04,343.04,344.04,345.04,346.04,347.04,348.04,349.04,350.04,351.04,352.04,353.04,354.04,355.04,356.04,357.04,358.04,359.04,360.04,361.04,362.04,363.04,364.04,365.04,366.04,367.04,368.04,369.04,370.04,371.04,110.02,110.02,113.02,113.02,114.02,114.02,114.02,115.02,115.02,115.02,116.02,116.02,116.02,117.02,117.02,117.02,118.02,118.02,118.02,119.02,119.02,119.02,120.02,120.02,120.02,121.02,121.02,121.02,122.02,122.02,122.02,123.02,123.02,123.02,124.02,124.02,113.02,113.02,114.02,114.02,114.02,115.02,115.02,115.02,116.02,116.02,116.02,117.02,117.02,117.02,118.02,118.02,118.02,119.02,119.02,119.02,120.02,120.02,120.02,121.02,121.02,121.02,122.02,122.02,122.02,123.02,123.02,123.02,124.02,124.02])
self.assertTrue(att5.getFieldOn(att5.getMyGodFather().getMeshAtPosition((0,0)),"YY").isEqualWithoutConsideringStr(exp19,1e-12))
exp20=DataArrayDouble([17.02,17.02,18.02,18.02,18.02,19.02,19.02,19.02,20.02,20.02,20.02,21.02,21.02,21.02,22.02,22.02,17.02,17.02,18.02,18.02,18.02,19.02,19.02,19.02,20.02,20.02,20.02,21.02,21.02,21.02,22.02,22.02,31.02,31.02,34.05,35.05,36.05,37.05,38.05,39.05,40.05,41.05,42.05,43.05,44.05,45.05,36.02,36.02,31.02,31.02,50.05,51.05,52.05,53.05,54.05,55.05,56.05,57.05,58.05,59.05,60.05,61.05,36.02,36.02,31.02,31.02,66.05,67.05,68.05,69.05,70.05,71.05,72.05,73.05,74.05,75.05,76.05,77.05,36.02,36.02,45.02,45.02,82.05,83.05,84.05,85.05,86.05,87.05,88.05,89.05,90.05,91.05,92.05,93.05,50.02,50.02,45.02,45.02,98.05,99.05,100.05,101.05,102.05,103.05,104.05,105.05,106.05,107.05,108.05,109.05,50.02,50.02,45.02,45.02,114.05,115.05,116.05,117.05,118.05,119.05,120.05,121.05,122.05,123.05,124.05,125.05,50.02,50.02,59.02,59.02,130.05,131.05,132.05,133.05,134.05,135.05,136.05,137.05,138.05,139.05,140.05,141.05,64.02,64.02,59.02,59.02,146.05,147.05,148.05,149.05,150.05,151.05,152.05,153.05,154.05,155.05,156.05,157.05,64.02,64.02,59.02,59.02,162.05,163.05,164.05,165.05,166.05,167.05,168.05,169.05,170.05,171.05,172.05,173.05,64.02,64.02,73.02,73.02,74.02,74.02,74.02,75.02,75.02,75.02,76.02,76.02,76.02,77.02,77.02,77.02,78.02,78.02,73.02,73.02,74.02,74.02,74.02,75.02,75.02,75.02,76.02,76.02,76.02,77.02,77.02,77.02,78.02,78.02])
exp4=DataArrayDouble([692.,692.,693.,693.,694.,694.,695.,695.,696.,696.,697.,697.,692.,692.,693.,693.,694.,694.,695.,695.,696.,696.,697.,697.,702.,702.,703.,703.,704.,704.,705.,705.,706.,706.,707.,707.,702.,702.,703.,703.,704.,704.,705.,705.,706.,706.,707.,707.,702.,702.,703.,703.,704.,704.,705.,705.,706.,706.,707.,707.,712.,712.,713.,713.,714.,714.,715.,715.,716.,716.,717.,717.,712.,712.,713.,713.,714.,714.,715.,715.,716.,716.,717.,717.,712.,712.,713.,713.,714.,714.,715.,715.,716.,716.,717.,717.,722.,722.,723.,723.,724.,724.,725.,725.,726.,726.,727.,727.,722.,722.,723.,723.,724.,724.,725.,725.,726.,726.,727.,727.])
exp=DataArrayDouble.Aggregate([exp0,exp0,exp1,exp1,exp1,exp1,exp2,exp2,exp2,exp2,exp3,exp3,exp3,exp3,exp4,exp4])
self.assertTrue(fine.isEqual(exp,1e-12))
+ #
fine.iota()
coarse.iota(0.5)
MEDCouplingIMesh.CondenseFineToCoarseGhost([6,7,5],fine,[(1,5),(2,4),(1,4)],[2,3,4],coarse,2)
vals=DataArrayDouble([11004.,11052.,11100.,11148.,11868.,11916.,11964.,12012.,22524.,22572.,22620.,22668.,23388.,23436.,23484.,23532.,34044.,34092.,34140.,34188.,34908.,34956.,35004.,35052.])
exp1[ids]=vals
self.assertTrue(coarse.isEqual(exp1,1e-12))
- MEDCouplingStructuredMesh.MultiplyPartOf([10,11,9],[(3,7),(4,6),(3,6)],1/24.,coarse)
#
+ MEDCouplingStructuredMesh.MultiplyPartOf([10,11,9],[(3,7),(4,6),(3,6)],1/24.,coarse)
exp2=DataArrayDouble(990) ; exp2.iota(0.5)
exp2[ids]=vals/24.
self.assertTrue(coarse.isEqual(exp2,1e-12))
+ #
+ coarse.iota(0.5) ; fine.iota(0.1)
+ MEDCouplingIMesh.SpreadCoarseToFineGhostZone(coarse,[6,7,5],fine,[(1,5),(2,4),(1,4)],[2,3,4],2)
+ #
+ coarse.iota(0.5) ; fine.iota(0.1)
+ MEDCouplingIMesh.SpreadCoarseToFineGhostZone(coarse,[6,7,5],fine,[(1,5),(2,4),(1,4)],[2,3,4],2)
+ exp00=DataArrayDouble.Aggregate([exp0,exp0]) ; exp00+=0.5
+ self.assertTrue(fine[:240].isEqual(exp00,1e-12))
+ exp44=DataArrayDouble.Aggregate([exp4,exp4]) ; exp44+=0.5
+ self.assertTrue(fine[-240:].isEqual(exp44,1e-12))
+ self.assertTrue(fine[240:-240].isEqual(DataArrayDouble([362.5,362.5,363.5,363.5,364.5,364.5,365.5,365.5,366.5,366.5,367.5,367.5,362.5,362.5,363.5,363.5,364.5,364.5,365.5,365.5,366.5,366.5,367.5,367.5,372.5,372.5,266.1,267.1,268.1,269.1,270.1,271.1,272.1,273.1,377.5,377.5,372.5,372.5,278.1,279.1,280.1,281.1,282.1,283.1,284.1,285.1,377.5,377.5,372.5,372.5,290.1,291.1,292.1,293.1,294.1,295.1,296.1,297.1,377.5,377.5,382.5,382.5,302.1,303.1,304.1,305.1,306.1,307.1,308.1,309.1,387.5,387.5,382.5,382.5,314.1,315.1,316.1,317.1,318.1,319.1,320.1,321.1,387.5,387.5,382.5,382.5,326.1,327.1,328.1,329.1,330.1,331.1,332.1,333.1,387.5,387.5,392.5,392.5,393.5,393.5,394.5,394.5,395.5,395.5,396.5,396.5,397.5,397.5,392.5,392.5,393.5,393.5,394.5,394.5,395.5,395.5,396.5,396.5,397.5,397.5,362.5,362.5,363.5,363.5,364.5,364.5,365.5,365.5,366.5,366.5,367.5,367.5,362.5,362.5,363.5,363.5,364.5,364.5,365.5,365.5,366.5,366.5,367.5,367.5,372.5,372.5,386.1,387.1,388.1,389.1,390.1,391.1,392.1,393.1,377.5,377.5,372.5,372.5,398.1,399.1,400.1,401.1,402.1,403.1,404.1,405.1,377.5,377.5,372.5,372.5,410.1,411.1,412.1,413.1,414.1,415.1,416.1,417.1,377.5,377.5,382.5,382.5,422.1,423.1,424.1,425.1,426.1,427.1,428.1,429.1,387.5,387.5,382.5,382.5,434.1,435.1,436.1,437.1,438.1,439.1,440.1,441.1,387.5,387.5,382.5,382.5,446.1,447.1,448.1,449.1,450.1,451.1,452.1,453.1,387.5,387.5,392.5,392.5,393.5,393.5,394.5,394.5,395.5,395.5,396.5,396.5,397.5,397.5,392.5,392.5,393.5,393.5,394.5,394.5,395.5,395.5,396.5,396.5,397.5,397.5,362.5,362.5,363.5,363.5,364.5,364.5,365.5,365.5,366.5,366.5,367.5,367.5,362.5,362.5,363.5,363.5,364.5,364.5,365.5,365.5,366.5,366.5,367.5,367.5,372.5,372.5,506.1,507.1,508.1,509.1,510.1,511.1,512.1,513.1,377.5,377.5,372.5,372.5,518.1,519.1,520.1,521.1,522.1,523.1,524.1,525.1,377.5,377.5,372.5,372.5,530.1,531.1,532.1,533.1,534.1,535.1,536.1,537.1,377.5,377.5,382.5,382.5,542.1,543.1,544.1,545.1,546.1,547.1,548.1,549.1,387.5,387.5,382.5,382.5,554.1,555.1,556.1,557.1,558.1,559.1,560.1,561.1,387.5,387.5,382.5,382.5,566.1,567.1,568.1,569.1,570.1,571.1,572.1,573.1,387.5,387.5,392.5,392.5,393.5,393.5,394.5,394.5,395.5,395.5,396.5,396.5,397.5,397.5,392.5,392.5,393.5,393.5,394.5,394.5,395.5,395.5,396.5,396.5,397.5,397.5,362.5,362.5,363.5,363.5,364.5,364.5,365.5,365.5,366.5,366.5,367.5,367.5,362.5,362.5,363.5,363.5,364.5,364.5,365.5,365.5,366.5,366.5,367.5,367.5,372.5,372.5,626.1,627.1,628.1,629.1,630.1,631.1,632.1,633.1,377.5,377.5,372.5,372.5,638.1,639.1,640.1,641.1,642.1,643.1,644.1,645.1,377.5,377.5,372.5,372.5,650.1,651.1,652.1,653.1,654.1,655.1,656.1,657.1,377.5,377.5,382.5,382.5,662.1,663.1,664.1,665.1,666.1,667.1,668.1,669.1,387.5,387.5,382.5,382.5,674.1,675.1,676.1,677.1,678.1,679.1,680.1,681.1,387.5,387.5,382.5,382.5,686.1,687.1,688.1,689.1,690.1,691.1,692.1,693.1,387.5,387.5,392.5,392.5,393.5,393.5,394.5,394.5,395.5,395.5,396.5,396.5,397.5,397.5,392.5,392.5,393.5,393.5,394.5,394.5,395.5,395.5,396.5,396.5,397.5,397.5,472.5,472.5,473.5,473.5,474.5,474.5,475.5,475.5,476.5,476.5,477.5,477.5,472.5,472.5,473.5,473.5,474.5,474.5,475.5,475.5,476.5,476.5,477.5,477.5,482.5,482.5,746.1,747.1,748.1,749.1,750.1,751.1,752.1,753.1,487.5,487.5,482.5,482.5,758.1,759.1,760.1,761.1,762.1,763.1,764.1,765.1,487.5,487.5,482.5,482.5,770.1,771.1,772.1,773.1,774.1,775.1,776.1,777.1,487.5,487.5,492.5,492.5,782.1,783.1,784.1,785.1,786.1,787.1,788.1,789.1,497.5,497.5,492.5,492.5,794.1,795.1,796.1,797.1,798.1,799.1,800.1,801.1,497.5,497.5,492.5,492.5,806.1,807.1,808.1,809.1,810.1,811.1,812.1,813.1,497.5,497.5,502.5,502.5,503.5,503.5,504.5,504.5,505.5,505.5,506.5,506.5,507.5,507.5,502.5,502.5,503.5,503.5,504.5,504.5,505.5,505.5,506.5,506.5,507.5,507.5,472.5,472.5,473.5,473.5,474.5,474.5,475.5,475.5,476.5,476.5,477.5,477.5,472.5,472.5,473.5,473.5,474.5,474.5,475.5,475.5,476.5,476.5,477.5,477.5,482.5,482.5,866.1,867.1,868.1,869.1,870.1,871.1,872.1,873.1,487.5,487.5,482.5,482.5,878.1,879.1,880.1,881.1,882.1,883.1,884.1,885.1,487.5,487.5,482.5,482.5,890.1,891.1,892.1,893.1,894.1,895.1,896.1,897.1,487.5,487.5,492.5,492.5,902.1,903.1,904.1,905.1,906.1,907.1,908.1,909.1,497.5,497.5,492.5,492.5,914.1,915.1,916.1,917.1,918.1,919.1,920.1,921.1,497.5,497.5,492.5,492.5,926.1,927.1,928.1,929.1,930.1,931.1,932.1,933.1,497.5,497.5,502.5,502.5,503.5,503.5,504.5,504.5,505.5,505.5,506.5,506.5,507.5,507.5,502.5,502.5,503.5,503.5,504.5,504.5,505.5,505.5,506.5,506.5,507.5,507.5,472.5,472.5,473.5,473.5,474.5,474.5,475.5,475.5,476.5,476.5,477.5,477.5,472.5,472.5,473.5,473.5,474.5,474.5,475.5,475.5,476.5,476.5,477.5,477.5,482.5,482.5,986.1,987.1,988.1,989.1,990.1,991.1,992.1,993.1,487.5,487.5,482.5,482.5,998.1,999.1,1000.1,1001.1,1002.1,1003.1,1004.1,1005.1,487.5,487.5,482.5,482.5,1010.1,1011.1,1012.1,1013.1,1014.1,1015.1,1016.1,1017.1,487.5,487.5,492.5,492.5,1022.1,1023.1,1024.1,1025.1,1026.1,1027.1,1028.1,1029.1,497.5,497.5,492.5,492.5,1034.1,1035.1,1036.1,1037.1,1038.1,1039.1,1040.1,1041.1,497.5,497.5,492.5,492.5,1046.1,1047.1,1048.1,1049.1,1050.1,1051.1,1052.1,1053.1,497.5,497.5,502.5,502.5,503.5,503.5,504.5,504.5,505.5,505.5,506.5,506.5,507.5,507.5,502.5,502.5,503.5,503.5,504.5,504.5,505.5,505.5,506.5,506.5,507.5,507.5,472.5,472.5,473.5,473.5,474.5,474.5,475.5,475.5,476.5,476.5,477.5,477.5,472.5,472.5,473.5,473.5,474.5,474.5,475.5,475.5,476.5,476.5,477.5,477.5,482.5,482.5,1106.1,1107.1,1108.1,1109.1,1110.1,1111.1,1112.1,1113.1,487.5,487.5,482.5,482.5,1118.1,1119.1,1120.1,1121.1,1122.1,1123.1,1124.1,1125.1,487.5,487.5,482.5,482.5,1130.1,1131.1,1132.1,1133.1,1134.1,1135.1,1136.1,1137.1,487.5,487.5,492.5,492.5,1142.1,1143.1,1144.1,1145.1,1146.1,1147.1,1148.1,1149.1,497.5,497.5,492.5,492.5,1154.1,1155.1,1156.1,1157.1,1158.1,1159.1,1160.1,1161.1,497.5,497.5,492.5,492.5,1166.1,1167.1,1168.1,1169.1,1170.1,1171.1,1172.1,1173.1,497.5,497.5,502.5,502.5,503.5,503.5,504.5,504.5,505.5,505.5,506.5,506.5,507.5,507.5,502.5,502.5,503.5,503.5,504.5,504.5,505.5,505.5,506.5,506.5,507.5,507.5,582.5,582.5,583.5,583.5,584.5,584.5,585.5,585.5,586.5,586.5,587.5,587.5,582.5,582.5,583.5,583.5,584.5,584.5,585.5,585.5,586.5,586.5,587.5,587.5,592.5,592.5,1226.1,1227.1,1228.1,1229.1,1230.1,1231.1,1232.1,1233.1,597.5,597.5,592.5,592.5,1238.1,1239.1,1240.1,1241.1,1242.1,1243.1,1244.1,1245.1,597.5,597.5,592.5,592.5,1250.1,1251.1,1252.1,1253.1,1254.1,1255.1,1256.1,1257.1,597.5,597.5,602.5,602.5,1262.1,1263.1,1264.1,1265.1,1266.1,1267.1,1268.1,1269.1,607.5,607.5,602.5,602.5,1274.1,1275.1,1276.1,1277.1,1278.1,1279.1,1280.1,1281.1,607.5,607.5,602.5,602.5,1286.1,1287.1,1288.1,1289.1,1290.1,1291.1,1292.1,1293.1,607.5,607.5,612.5,612.5,613.5,613.5,614.5,614.5,615.5,615.5,616.5,616.5,617.5,617.5,612.5,612.5,613.5,613.5,614.5,614.5,615.5,615.5,616.5,616.5,617.5,617.5,582.5,582.5,583.5,583.5,584.5,584.5,585.5,585.5,586.5,586.5,587.5,587.5,582.5,582.5,583.5,583.5,584.5,584.5,585.5,585.5,586.5,586.5,587.5,587.5,592.5,592.5,1346.1,1347.1,1348.1,1349.1,1350.1,1351.1,1352.1,1353.1,597.5,597.5,592.5,592.5,1358.1,1359.1,1360.1,1361.1,1362.1,1363.1,1364.1,1365.1,597.5,597.5,592.5,592.5,1370.1,1371.1,1372.1,1373.1,1374.1,1375.1,1376.1,1377.1,597.5,597.5,602.5,602.5,1382.1,1383.1,1384.1,1385.1,1386.1,1387.1,1388.1,1389.1,607.5,607.5,602.5,602.5,1394.1,1395.1,1396.1,1397.1,1398.1,1399.1,1400.1,1401.1,607.5,607.5,602.5,602.5,1406.1,1407.1,1408.1,1409.1,1410.1,1411.1,1412.1,1413.1,607.5,607.5,612.5,612.5,613.5,613.5,614.5,614.5,615.5,615.5,616.5,616.5,617.5,617.5,612.5,612.5,613.5,613.5,614.5,614.5,615.5,615.5,616.5,616.5,617.5,617.5,582.5,582.5,583.5,583.5,584.5,584.5,585.5,585.5,586.5,586.5,587.5,587.5,582.5,582.5,583.5,583.5,584.5,584.5,585.5,585.5,586.5,586.5,587.5,587.5,592.5,592.5,1466.1,1467.1,1468.1,1469.1,1470.1,1471.1,1472.1,1473.1,597.5,597.5,592.5,592.5,1478.1,1479.1,1480.1,1481.1,1482.1,1483.1,1484.1,1485.1,597.5,597.5,592.5,592.5,1490.1,1491.1,1492.1,1493.1,1494.1,1495.1,1496.1,1497.1,597.5,597.5,602.5,602.5,1502.1,1503.1,1504.1,1505.1,1506.1,1507.1,1508.1,1509.1,607.5,607.5,602.5,602.5,1514.1,1515.1,1516.1,1517.1,1518.1,1519.1,1520.1,1521.1,607.5,607.5,602.5,602.5,1526.1,1527.1,1528.1,1529.1,1530.1,1531.1,1532.1,1533.1,607.5,607.5,612.5,612.5,613.5,613.5,614.5,614.5,615.5,615.5,616.5,616.5,617.5,617.5,612.5,612.5,613.5,613.5,614.5,614.5,615.5,615.5,616.5,616.5,617.5,617.5,582.5,582.5,583.5,583.5,584.5,584.5,585.5,585.5,586.5,586.5,587.5,587.5,582.5,582.5,583.5,583.5,584.5,584.5,585.5,585.5,586.5,586.5,587.5,587.5,592.5,592.5,1586.1,1587.1,1588.1,1589.1,1590.1,1591.1,1592.1,1593.1,597.5,597.5,592.5,592.5,1598.1,1599.1,1600.1,1601.1,1602.1,1603.1,1604.1,1605.1,597.5,597.5,592.5,592.5,1610.1,1611.1,1612.1,1613.1,1614.1,1615.1,1616.1,1617.1,597.5,597.5,602.5,602.5,1622.1,1623.1,1624.1,1625.1,1626.1,1627.1,1628.1,1629.1,607.5,607.5,602.5,602.5,1634.1,1635.1,1636.1,1637.1,1638.1,1639.1,1640.1,1641.1,607.5,607.5,602.5,602.5,1646.1,1647.1,1648.1,1649.1,1650.1,1651.1,1652.1,1653.1,607.5,607.5,612.5,612.5,613.5,613.5,614.5,614.5,615.5,615.5,616.5,616.5,617.5,617.5,612.5,612.5,613.5,613.5,614.5,614.5,615.5,615.5,616.5,616.5,617.5,617.5]),1e-12))
+ pass
+
+ def testSwig2AMR12(self):
+ """ This test check the MEDCouplingAMRAttribute.projectTo method."""
+ amr0=MEDCouplingCartesianAMRMesh("mesh",2,[11,11],[0.,0.],[1.,1.])
+ amr0.addPatch([(3,8),(0,3)],[2,2])
+ amr0.addPatch([(3,8),(3,6)],[2,2])
+ att0=MEDCouplingAMRAttribute(amr0,[("YY",1)],2)
+ att0.alloc()
+ att0.getFieldOn(amr0,"YY").iota(0.01)
+ att0.getFieldOn(amr0[0].getMesh(),"YY").iota(0.02)
+ att0.getFieldOn(amr0[1].getMesh(),"YY").iota(0.03)
+ amr1=MEDCouplingCartesianAMRMesh("mesh",2,[11,11],[0.,0.],[1.,1.])
+ amr1.addPatch([(2,5),(1,4)],[2,2])
+ att1=att0.projectTo(amr1)
+ self.assertTrue(att1.getFieldOn(amr1,"YY").isEqualWithoutConsideringStr(att0.getFieldOn(amr0,"YY"),1e-12))
+ self.assertTrue(att1.getFieldOn(amr1[0].getMesh(),"YY").isEqualWithoutConsideringStr(DataArrayDouble([31.01,31.01,32.01,32.01,33.01,33.01,34.01,34.01,35.01,35.01,31.01,31.01,32.01,32.01,33.01,33.01,34.01,34.01,35.01,35.01,45.01,45.01,46.01,46.01,58.02,59.02,60.02,61.02,49.01,49.01,45.01,45.01,46.01,46.01,72.02,73.02,74.02,75.02,49.01,49.01,59.01,59.01,60.01,60.01,86.02,87.02,88.02,89.02,63.01,63.01,59.01,59.01,60.01,60.01,100.02,101.02,102.02,103.02,63.01,63.01,73.01,73.01,74.01,74.01,30.03,31.03,32.03,33.03,77.01,77.01,73.01,73.01,74.01,74.01,44.03,45.03,46.03,47.03,77.01,77.01,87.01,87.01,88.01,88.01,89.01,89.01,90.01,90.01,91.01,91.01,87.01,87.01,88.01,88.01,89.01,89.01,90.01,90.01,91.01,91.01]),1e-12))
+ #
+ amr0=MEDCouplingCartesianAMRMesh("mesh",2,[11,11],[0.,0.],[1.,1.])
+ amr0.addPatch([(2,5),(2,7)],[2,2])
+ amr0.addPatch([(5,8),(2,7)],[2,2])
+ att0=MEDCouplingAMRAttribute(amr0,[("YY",1)],2)
+ att0.alloc()
+ att0.getFieldOn(amr0,"YY").iota(0.01)
+ att0.getFieldOn(amr0[0].getMesh(),"YY").iota(0.02)
+ att0.getFieldOn(amr0[1].getMesh(),"YY").iota(0.03)
+ amr1=MEDCouplingCartesianAMRMesh("mesh",2,[11,11],[0.,0.],[1.,1.])
+ amr1.addPatch([(3,6),(2,7)],[2,2])
+ amr1.addPatch([(6,9),(2,7)],[2,2])
+ att1=att0.projectTo(amr1)
+ self.assertTrue(att1.getFieldOn(amr1,"YY").isEqual(att0.getFieldOn(amr0,"YY"),1e-12))
+ self.assertTrue(att1.getFieldOn(amr1[0].getMesh(),"YY").isEqualWithoutConsideringStr(DataArrayDouble([46.01,46.01,47.01,47.01,48.01,48.01,49.01,49.01,50.01,50.01,46.01,46.01,47.01,47.01,48.01,48.01,49.01,49.01,50.01,50.01,60.01,60.01,24.02,25.02,26.02,27.02,22.03,23.03,64.01,64.01,60.01,60.01,34.02,35.02,36.02,37.02,32.03,33.03,64.01,64.01,74.01,74.01,44.02,45.02,46.02,47.02,42.03,43.03,78.01,78.01,74.01,74.01,54.02,55.02,56.02,57.02,52.03,53.03,78.01,78.01,88.01,88.01,64.02,65.02,66.02,67.02,62.03,63.03,92.01,92.01,88.01,88.01,74.02,75.02,76.02,77.02,72.03,73.03,92.01,92.01,102.01,102.01,84.02,85.02,86.02,87.02,82.03,83.03,106.01,106.01,102.01,102.01,94.02,95.02,96.02,97.02,92.03,93.03,106.01,106.01,116.01,116.01,104.02,105.02,106.02,107.02,102.03,103.03,120.01,120.01,116.01,116.01,114.02,115.02,116.02,117.02,112.03,113.03,120.01,120.01,130.01,130.01,131.01,131.01,132.01,132.01,133.01,133.01,134.01,134.01,130.01,130.01,131.01,131.01,132.01,132.01,133.01,133.01,134.01,134.01]),1e-12))
+ self.assertTrue(att1.getFieldOn(amr1[1].getMesh(),"YY").isEqualWithoutConsideringStr(DataArrayDouble([49.01,49.01,50.01,50.01,51.01,51.01,52.01,52.01,53.01,53.01,49.01,49.01,50.01,50.01,51.01,51.01,52.01,52.01,53.01,53.01,63.01,63.01,24.03,25.03,26.03,27.03,66.01,66.01,67.01,67.01,63.01,63.01,34.03,35.03,36.03,37.03,66.01,66.01,67.01,67.01,77.01,77.01,44.03,45.03,46.03,47.03,80.01,80.01,81.01,81.01,77.01,77.01,54.03,55.03,56.03,57.03,80.01,80.01,81.01,81.01,91.01,91.01,64.03,65.03,66.03,67.03,94.01,94.01,95.01,95.01,91.01,91.01,74.03,75.03,76.03,77.03,94.01,94.01,95.01,95.01,105.01,105.01,84.03,85.03,86.03,87.03,108.01,108.01,109.01,109.01,105.01,105.01,94.03,95.03,96.03,97.03,108.01,108.01,109.01,109.01,119.01,119.01,104.03,105.03,106.03,107.03,122.01,122.01,123.01,123.01,119.01,119.01,114.03,115.03,116.03,117.03,122.01,122.01,123.01,123.01,133.01,133.01,134.01,134.01,135.01,135.01,136.01,136.01,137.01,137.01,133.01,133.01,134.01,134.01,135.01,135.01,136.01,136.01,137.01,137.01]),1e-12))
+ pass
+
+ def testSwig2AMR13(self):
+ """ non regression test"""
+ for fact,len1,len2 in [([2,2],64,48),([3,3],100,70),([4,4],144,96)]:
+ amr=MEDCouplingCartesianAMRMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
+ amr.addPatch([(1,3),(0,2)],fact)
+ amr.addPatch([(1,3),(3,4)],fact)
+ att=MEDCouplingAMRAttribute(amr,[("YY",1)],2)
+ att.alloc()
+ att.getFieldOn(amr,"YY").iota(0.1)
+ att.getFieldOn(amr[0].getMesh(),"YY").iota(0.2)
+ att.getFieldOn(amr[1].getMesh(),"YY").iota(0.3)
+ att.synchronizeAllGhostZonesOfDirectChidrenOf(amr)
+ exp=DataArrayDouble(64) ; exp.iota(0.1)
+ self.assertTrue(att.getFieldOn(amr,"YY").isEqualWithoutConsideringStr(exp,1e-12))
+ exp0=DataArrayDouble(len1) ; exp0.iota(0.2)
+ self.assertTrue(att.getFieldOn(amr[0].getMesh(),"YY").isEqualWithoutConsideringStr(exp0,1e-12))
+ exp1=DataArrayDouble(len2) ; exp1.iota(0.3)
+ self.assertTrue(att.getFieldOn(amr[1].getMesh(),"YY").isEqualWithoutConsideringStr(exp1,1e-12))
+ pass
+ pass
+
+ def testSwig2AMR14(self):
+ """ non regression linked to VTHB write."""
+ fact=[2,2] ; fact2=[3,3]
+ amr=MEDCouplingCartesianAMRMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
+ amr.addPatch([(1,3),(0,2)],fact)
+ amr.addPatch([(1,3),(3,4)],fact)
+ amr[0].addPatch([(1,3),(1,3)],fact2)
+ amr[1].addPatch([(1,3),(1,2)],fact2)
+ att=MEDCouplingAMRAttribute(amr,[("YY",1)],2)
+ att.alloc()
+ att.getFieldOn(amr,"YY").iota(0.1)
+ att.getFieldOn(amr[0].getMesh(),"YY").iota(0.2)
+ att.getFieldOn(amr[1].getMesh(),"YY").iota(0.3)
+ att.getFieldOn(amr[0][0].getMesh(),"YY").iota(0.4)
+ att.getFieldOn(amr[1][0].getMesh(),"YY").iota(0.5)
+ self.assertEqual(amr[0].getBLTRRangeRelativeToGF(),[(2,6),(0,4)])
+ self.assertEqual(amr[1].getBLTRRangeRelativeToGF(),[(2,6),(6,8)])
+ self.assertEqual(amr[0][0].getBLTRRangeRelativeToGF(),[(9,15),(3,9)])
+ self.assertEqual(amr[1][0].getBLTRRangeRelativeToGF(),[(9,15),(21,24)])
+ pass
+
+ def testSwig2Intersect2DMeshWith1DLine1(self):
+ """A basic test with no colinearity between m1 and m2."""
+ i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
+ m1=i.buildUnstructured()
+ m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([0.75,3.5,3.75,1.75],2,2)) ; m2.allocateCells() ; m2.insertNextCell(NORM_SEG2,[0,1])
+ a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
+ self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,5,6,4,2,1,6,7,4,3,2,7,8,4,4,3,8,9,4,6,5,10,11,4,7,6,11,12,4,8,7,12,13,4,11,10,15,16,4,18,17,22,23,4,19,18,23,24,5,16,15,20,21,31,5,21,22,17,28,31,5,16,31,28,5,17,29,28,5,12,11,16,28,29,5,17,18,30,29,5,13,12,29,30,5,18,19,14,27,30,5,13,30,27,5,9,8,13,27,14])))
+ self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,25,31,1,31,28,1,28,29,1,29,30,1,30,27,1,27,26])))
+ self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,56,62,66,70,76,81,86,92,96,102])))
+ self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18])))
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[25:25+2].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[27:].isEqualWithoutConsideringStr(DataArrayDouble([(3.3214285714285716,2.),(1.6071428571428572,3.),(2.,2.7708333333333335),(3.,2.1875),(1.,3.354166666666667)]),1e-12))
+ self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,4,5,6,8,14,15,12,13,13,9,9,10,10,11,11,7])))
+ self.assertTrue(d.isEqual(DataArrayInt([(10,10),(11,12),(13,14),(15,16),(17,18),(19,19)])))
+ pass
+
+ def testSwig2Intersect2DMeshWith1DLine2(self):
+ """A basic test with colinearity between m1 and m2 and the last cell of m2 outside m1."""
+ i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
+ m1=i.buildUnstructured()
+ m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([0.5,2.,2.25,2.,2.5,2.,2.75,2.,3.,2.,4.,2.,5.,2.],7,2)) ; m2.allocateCells()
+ for i in xrange(6):
+ m2.insertNextCell(NORM_SEG2,[i,i+1])
+ pass
+ a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
+ self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,5,6,4,2,1,6,7,4,3,2,7,8,4,4,3,8,9,4,16,15,20,21,4,17,16,21,22,4,18,17,22,23,4,19,18,23,24,5,6,5,10,25,11,5,7,6,11,12,5,8,7,12,26,27,28,13,5,9,8,13,14,5,11,25,10,15,16,5,12,11,16,17,5,13,28,27,26,12,17,18,5,14,13,18,19])))
+ self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,46,51,59,64,70,75,83,88])))
+ self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,25,11,1,11,12,1,12,26,1,26,27,1,27,28,1,28,13,1,13,14,1,14,31])))
+ self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24])))
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[25:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
+ self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,12,13,14,15,4,5,6,7,8,9,10,11])))
+ self.assertTrue(d.isEqual(DataArrayInt([(12,8),(13,9),(14,10),(14,10),(14,10),(14,10),(15,11),(-1,-1)])))
+ pass
+
+ def testSwig2Intersect2DMeshWith1DLine3(self):
+ """m2 fully included in cell #12. of m1"""
+ i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
+ m1=i.buildUnstructured()
+ m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([(0.75,3.25),(0.5,3.5),(0.25,3.25)])) ; m2.allocateCells()
+ for i in xrange(2):
+ m2.insertNextCell(NORM_SEG2,[i,i+1])
+ pass
+ a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
+ self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,5,6,4,2,1,6,7,4,3,2,7,8,4,4,3,8,9,4,6,5,10,11,4,7,6,11,12,4,8,7,12,13,4,9,8,13,14,4,11,10,15,16,4,12,11,16,17,4,13,12,17,18,4,14,13,18,19,4,17,16,21,22,4,18,17,22,23,4,19,18,23,24,5,16,15,20,21])))
+ self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80])))
+ self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,25,26,1,26,27])))
+ self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6])))
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[25:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
+ self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,13,14,15,12])))
+ self.assertTrue(d.isEqual(DataArrayInt([(15,15),(15,15)])))
+ pass
+
+ def testSwig2Intersect2DMeshWith1DLine4(self):
+ """A special case where an edge is simultaneously a cut and colinear. This tests also checks negative values in descending edges of m1."""
+ i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
+ m1=i.buildUnstructured()
+ part=DataArrayInt([0,1,2,3,4,7,8,11,12,13,14,15])
+ m1_1=m1[part]
+ m1_2=m1[part.buildComplement(m1.getNumberOfCells())]
+ m1=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m1_1,m1_2.buildSpreadZonesWithPoly())
+ m1.zipCoords()
+ m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([(3.5,2.),(0.5,2.)])) ; m2.allocateCells()
+ m2.insertNextCell(NORM_SEG2,[0,1])
+ a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
+ self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,5,6,4,2,1,6,7,4,3,2,7,8,4,4,3,8,9,4,15,14,19,20,4,16,15,20,21,4,17,16,21,22,4,18,17,22,23,5,6,5,10,25,11,5,9,8,12,24,13,5,11,25,10,14,15,5,13,24,12,17,18,5,8,7,6,11,12,5,15,16,17,12,11])))
+ self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,46,52,58,64,70,76])))
+ self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,24,12,1,12,11,1,11,25])))
+ self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9])))
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertTrue(a.getCoords()[:24].isEqual(m1.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[24:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
+ self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,8,9,10,11,4,5,6,7,12,12])))
+ self.assertTrue(d.isEqual(DataArrayInt([(9,11),(12,13),(8,10)])))
+ pass
+
+ def testSwig2Intersect2DMeshWith1DLine5(self):
+ """A test focusing on a special case for cut."""
+ i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
+ m1=i.buildUnstructured()
+ m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([(1.,0.),(3.,2.),(1.,4.)])) ; m2.allocateCells()
+ for i in xrange(2):
+ m2.insertNextCell(NORM_SEG2,[i,i+1])
+ pass
+ a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
+ self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,5,6,4,3,2,7,8,4,4,3,8,9,4,6,5,10,11,4,7,6,11,12,4,9,8,13,14,4,11,10,15,16,4,12,11,16,17,4,14,13,18,19,4,16,15,20,21,4,18,17,22,23,4,19,18,23,24,5,6,7,1,5,2,1,7,5,12,13,7,5,8,7,13,5,12,17,13,5,18,13,17,5,16,21,17,5,22,17,21])))
+ self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,64,68,72,76,80,84,88,92])))
+ self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,1,7,1,7,13,1,13,17,1,17,21])))
+ self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12])))
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[25:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
+ self.assertTrue(c.isEqual(DataArrayInt([0,2,3,4,5,7,8,9,11,12,14,15,1,1,6,6,10,10,13,13])))
+ self.assertTrue(d.isEqual(DataArrayInt([(12,13),(14,15),(16,17),(18,19)])))
+ pass
+
+ def testIntersect2DMeshWith1DLine6(self):
+ """ Basic test for Intersect2DMeshWith1DLine: a vertical line intersecting a square. """
+ m1c = MEDCouplingCMesh()
+ coordX = DataArrayDouble([-1., 1., 2])
+ m1c.setCoordsAt(0,coordX)
+ coordY = DataArrayDouble([0., 2.])
+ m1c.setCoordsAt(1,coordY);
+ m1 = m1c.buildUnstructured()
+
+ # A simple line:
+ m2 = MEDCouplingUMesh("bla", 1)
+ coord2 = DataArrayDouble([0.,-1.0, 0.,1., 0.,3., 0.5,2.2], 4, 2)
+ conn2 = DataArrayInt([NORM_SEG2,0,1,NORM_SEG3,1,2,3])
+ connI2 = DataArrayInt([0,3,7])
+ m2.setCoords(coord2)
+ m2.setConnectivity(conn2, connI2)
+
+ # End of construction of input meshes m1bis and m2 -> start of specific part of the test
+ a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
+ self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,2,1,4,5,32,0,3,11,7,10,14,15,16,17,18,32,4,1,10,7,11,19,20,21,22,23])))
+ self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,16,27])))
+ self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,6,10,1,10,7,2,7,11,12,2,11,8,13])))
+ self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,10,14])))
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertTrue(a.getCoords()[:6].isEqual(m1.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[6:10].isEqual(m2.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[10:].isEqual(DataArrayDouble([(0.,0.),(0.5164175471673584,2.),(0.3796918047064557,1.43726403104512),(0.3796918047064557,2.56273596895488),(-1.,1.),(-0.24179122641632078,2.),(0.3796918047064558,1.4372640310451201),(0.,0.5),(-0.5,0.),(1.,1.),(0.5,0.),(0.,0.5),(0.3796918047064558,1.4372640310451201),(0.7582087735836792,2.)]),1e-12))
+ self.assertTrue(c.isEqual(DataArrayInt([1,0,0])))
+ self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(1,2),(-1,-1)])))
+ pass
+
+ def testSwig2Intersect2DMeshWith1DLine7(self):
+ """ Star pattern (a triangle intersecting another one upside down) """
+ coords1 = DataArrayDouble([-2.,1., 2.,1., 0.,-2.], 3,2)
+ coords2 = DataArrayDouble([0.,2., 2.,-1., -2.,-1., 0.,3.], 4,2)
+ m1 = MEDCouplingUMesh("triangle", 2)
+ m2 = MEDCouplingUMesh("tri_line", 1)
+ m1.setCoords(coords1)
+ m2.setCoords(coords2)
+ m1.setConnectivity(DataArrayInt([NORM_TRI3, 0,1,2]), DataArrayInt([0,4]))
+ m2.setConnectivity(DataArrayInt([NORM_SEG2,0,1,NORM_SEG2,1,2,NORM_SEG2,2,3]), DataArrayInt([0,3,6,9]))
+ # End of construction of input meshes m1bis and m2 -> start of specific part of the test
+ a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
+ self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([5,1,9,7,5,2,11,10,5,0,8,12,5,7,9,10,11,12,8])))
+ self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,19])))
+ self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,3,7,1,7,9,1,9,4,1,4,10,1,10,11,1,11,5,1,5,12,1,12,8,1,8,6])))
+ self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24,27])))
+ self.assertTrue(a.getCoords()[:3].isEqual(m1.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[3:7].isEqual(m2.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[7:].isEqual(DataArrayDouble([(0.6666666666666666,1.),(-1.,1.),(1.3333333333333333,1.1102230246251565e-16),(0.6666666666666665,-0.9999999999999996),(-0.6666666666666667,-1.),(-1.4285714285714284,0.14285714285714302)]),1e-12))
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertTrue(c.isEqual(DataArrayInt([0,0,0,0])))
+ self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(0,3),(-1,-1),(-1,-1),(1,3),(-1,-1),(-1,-1),(2,3),(-1,-1)])))
+ pass
+
+ def testSwig2Intersect2DMeshWith1DLine8(self):
+ """ Line pieces ending (or fully located) in the middle of a cell """
+ m1c = MEDCouplingCMesh()
+ m1c.setCoordsAt(0,DataArrayDouble([-1., 1.]))
+ m1c.setCoordsAt(1,DataArrayDouble([-1., 1.]));
+ m1 = m1c.buildUnstructured()
+ coords2 = DataArrayDouble([0.,0., 0.,1.5, -1.5,0., 0.5,0.0, 0.0,-0.5, 1.1,-0.6], 6,2)
+ m2 = MEDCouplingUMesh("piecewise_line", 1)
+ m2.setCoords(coords2)
+ c = DataArrayInt([NORM_SEG2,2,1, NORM_SEG2,1,4, NORM_SEG2,4,3, NORM_SEG2,3,5])
+ cI = DataArrayInt([0,3,6,9,12])
+ m2.setConnectivity(c, cI)
+ a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
+ self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([5,2,11,10,5,3,13,7,8,12,5,1,0,10,11,12,8,7,13])))
+ self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,10,19])))
+ self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,6,10,1,10,11,1,11,5,1,5,12,1,12,8,1,8,7,1,7,13,1,13,9])))
+ self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24])))
+ self.assertTrue(a.getCoords()[:4].isEqual(m1.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[4:10].isEqual(m2.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[10:].isEqual(DataArrayDouble([(-1.,0.5),(-0.5,1.),(0.,1.),(1.,-0.5)]),1e-12))
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertTrue(c.isEqual(DataArrayInt([0,0,0])))
+ self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(0,2),(-1,-1),(-1,-1),(1,2),(1,2),(1,2),(-1,-1)])))
+ pass
+
+ def testSwig2Intersect2DMeshWith1DLine9(self):
+ """ Intersection with a line whose connectivity is not consecutive """
+ m1c = MEDCouplingCMesh()
+ coordX = DataArrayDouble([-1., 1., 2])
+ m1c.setCoordsAt(0,coordX)
+ coordY = DataArrayDouble([0., 2.])
+ m1c.setCoordsAt(1,coordY);
+ m1 = m1c.buildUnstructured()
+ # A simple line:
+ m2 = MEDCouplingUMesh("bla", 1)
+ coord2 = DataArrayDouble([0.,1.5, 0.5,1., 0.0,0.5, 0.0,3.0, 0.0,-1.0], 5, 2)
+ conn2 = DataArrayInt([NORM_SEG2,3,0,NORM_SEG3,0,2,1,NORM_SEG2,2,4])
+ connI2 = DataArrayInt([0,3,7,10])
+ m2.setCoords(coord2)
+ m2.setConnectivity(conn2, connI2)
+ # End of construction of input meshes m1bis and m2 -> start of specific part of the test
+ a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
+ self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,2,1,4,5,32,4,1,11,8,6,12,14,15,16,17,18,19,32,0,3,12,6,8,11,20,21,22,23,24,25])))
+ self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,18,31])))
+ self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,9,12,1,12,6,2,6,8,13,1,8,11,1,11,10])))
+ self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,10,13,16])))
+ self.assertTrue(a.getCoords()[:6].isEqual(m1.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[6:11].isEqual(m2.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[11:].isEqual(DataArrayDouble([(0.,0.),(0.,2.),(0.5,1.),(1.,1.),(0.5,0.),(0.,0.25),(0.5,1.),(0.,1.75),(0.5,2.),(-1.,1.),(-0.5,2.),(0.,1.75),(0.5,1.),(0.,0.25),(-0.5,0.)]),1e-12))
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertTrue(c.isEqual(DataArrayInt([1,0,0])))
+ self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(1,2),(1,2),(-1,-1)])))
+ pass
+
+ def testSwig2Intersect2DMeshWith1DLine10(self):
+ """ Intersection between a circle and various lines """
+ eps = 1.0e-8
+ m_circ = MEDCouplingDataForTest.buildCircle2(0.0, 0.0, 2.0)
+ coords = [0.0,3.0,0.0,-3.0]
+ connec = [0,1]
+ m_line = MEDCouplingUMesh("seg", 1)
+ m_line.allocateCells(1)
+ meshCoords = DataArrayDouble.New(coords, len(coords)/2, 2)
+ m_line.setCoords(meshCoords)
+ m_line.insertNextCell(NORM_SEG2, connec)
+ a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m_circ, m_line, eps)
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertTrue(a.getCoords()[:m_circ.getNumberOfNodes()].isEqual(m_circ.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[m_circ.getNumberOfNodes():m_circ.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
+ self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(2.,0.),(1.4142135623730951,1.414213562373095),(0.,2.),(-1.414213562373095,1.4142135623730951),(-2.,0.),(-1.4142135623730954,-1.414213562373095),(0.,-2.),(1.4142135623730947,-1.4142135623730954),(0.,3.),(0.,-3.),(0.,-2.),(0.,2.),(2.,0.),(0.7653668647301797,-1.8477590650225735),(0.,0.),(0.7653668647301797,1.8477590650225735),(-2,0.),(-0.7653668647301795,1.8477590650225735),(0.,0.),(-0.7653668647301795,-1.8477590650225735)]),1e-12))
+ self.assertEqual([32,1,7,10,11,12,13,14,15,32,5,3,11,10,16,17,18,19],a.getNodalConnectivity().getValues())
+ self.assertEqual([0,9,18], a.getNodalConnectivityIndex().getValues())
+ self.assertEqual([1,8,11,1,11,10,1,10,9],b.getNodalConnectivity().getValues())
+ self.assertEqual([0,3,6,9],b.getNodalConnectivityIndex().getValues())
+ self.assertTrue(a.getCoords()[:8].isEqual(m_circ.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[8:10].isEqual(m_line.getCoords(),1e-12))
+ coo_tgt = DataArrayDouble([2.,0.,1.4142135623730951,1.414213562373095,1.2246467991473532e-16,2.,-1.414213562373095,1.4142135623730951,-2.,0.,-1.4142135623730954,-1.414213562373095,-3.6739403974420594e-16,-2.,1.4142135623730947,-1.4142135623730954,0.,3.,0.,-3.,0.,-2.,0.,2.,2.,0.,0.7653668647301797,-1.8477590650225735,0.,0.,0.7653668647301797,1.8477590650225735,-2.,0.,-0.7653668647301795,1.8477590650225735,0.,0.,-0.7653668647301795,-1.8477590650225735])
+ self.assertTrue(a.getCoords().isEqualWithoutConsideringStr(coo_tgt,1.0e-12))
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertEqual([0,0],c.getValues())
+ self.assertEqual([-1,-1,0,1,-1,-1],d.getValues())
+
+ def testSwig2Intersect2DMeshWith1DLine11(self):
+ """ Quad line re-entering a square cell """
+ eps = 1.0e-8
+ m = MEDCouplingUMesh("box", 2)
+ m.setCoords(DataArrayDouble([-1., -1., -1., 1., 1., 1., 1., -1.0],4,2))
+ c, cI = [NORM_POLYGON, 0, 1, 2, 3], [0, 5]
+ m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
+ m.checkCoherency()
+ coords2 = [0., 1.3, -1.3, 0., -0.6, 0.6, 0., -1.3, -0.5, -0.5]
+ connec2, cI2 = [NORM_SEG3, 0, 1, 2, NORM_SEG3, 1, 3, 4], [0,4,8]
+ m_line = MEDCouplingUMesh("seg", 1)
+ m_line.setCoords(DataArrayDouble(coords2, len(coords2)/2, 2))
+ m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
+ a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
+ self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(-1.,-1.),(-1.,1.),(1.,1.),(1.,-1.),(0.,1.3),(-1.3,0.),(-0.6,0.6),(0.,-1.3),(-0.5,-0.5),(-1.,0.23453685964236054),(-1.,-0.13033276368660177),(-0.2345368596423598,1.),(-0.1303327636866019,-1.),(-0.11489196370692323,1.1481421036683868),(-0.6,0.6),(-1.1481421036683859,0.11489196370692323),(-1.147455889106615,-0.0593103465193594),(-0.5,-0.5),(-0.0593103465193594,-1.147455889106615),(1.,0.),(0.4348336181566991,-1.),(-0.5651663818433009,-1.),(-1.,-0.5651663818433009),(-1.,0.05210204797787939),(-0.6,0.6),(0.3827315701788201,1.),(-0.6172684298211799,1.),(-0.6,0.6),(-1.,0.6172684298211802),(-0.6,0.6),(0.3827315701788201,1.),(1.,0.),(0.4348336181566991,-1.),(-0.5,-0.5),(-1.,0.05210204797787939),(-1.,-0.5651663818433009),(-0.5,-0.5),(-0.5651663818433009,-1.)]),1e-12))
+ self.assertEqual([32,9,11,2,3,12,10,29,30,31,32,33,34,32,0,10,12,35,36,37,32,1,11,9,26,27,28],a.getNodalConnectivity().getValues())
+ self.assertEqual([0,13,20,27],a.getNodalConnectivityIndex().getValues())
+ self.assertEqual([2,4,11,13,2,11,9,14,2,9,5,15,2,5,10,16,2,10,12,17,2,12,7,18],b.getNodalConnectivity().getValues())
+ self.assertEqual([0,4,8,12,16,20,24],b.getNodalConnectivityIndex().getValues())
+ self.assertTrue(a.getCoords()[:4].isEqual(m.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[4:9].isEqual(m_line.getCoords(),1e-12))
+ self.assertTrue(DataArrayInt([0,0,0]).isEqual(c))
+ self.assertTrue(DataArrayInt([(-1,-1),(0,2),(-1,-1),(-1,-1),(0,1),(-1,-1)]).isEqual(d))
+ pass
+
+ def testSwig2Intersect2DMeshWith1DLine12(self):
+ """ Two squares one in the other intersected by an horizontal line """
+ eps = 1.0e-8
+ m = MEDCouplingUMesh("boxbox", 2)
+ m.setCoords(DataArrayDouble([-0.5,-0.5,-0.5,0.5,0.5,0.5,0.5,-0.5,-0.25,-0.25,-0.25,0.25,0.25,0.25,0.25,-0.25],8,2))
+ c = [NORM_POLYGON, 4, 5, 6, 7, NORM_POLYGON, 0, 1, 5, 4, NORM_POLYGON, 1, 2, 3, 0, 4, 7, 6, 5]
+ cI = [0, 5, 10, 19]
+ m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
+ m.checkCoherency()
+ coords2 = [-1., 0.25, 1., 0.25]
+ connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
+ m_line = MEDCouplingUMesh.New("seg", 1)
+ m_line.setCoords(DataArrayDouble(coords2, len(coords2)/2, 2))
+ m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
+ m_line2 = m_line.deepCpy()
+ m2 = m.deepCpy()
+ a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
+ self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(-0.5,-0.5),(-0.5,0.5),(0.5,0.5),(0.5,-0.5),(-0.25,-0.25),(-0.25,0.25),(0.25,0.25),(0.25,-0.25),(-1.,0.25),(1.,0.25),(-0.5,0.25),(0.5,0.25)]),1e-12))
+ self.assertEqual([5,4,5,6,7,5,1,5,10,5,4,0,10,5,5,5,1,2,11,6,5,3,0,4,7,6,11],a.getNodalConnectivity().getValues())
+ self.assertEqual([0,5,9,14,20,27],a.getNodalConnectivityIndex().getValues())
+ self.assertEqual([1,8,10,1,10,5,1,5,6,1,6,11,1,11,9],b.getNodalConnectivity().getValues())
+ self.assertEqual([0,3,6,9,12,15],b.getNodalConnectivityIndex().getValues())
+ self.assertTrue(c.isEqual(DataArrayInt([0,1,1,2,2])))
+ self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(3,0),(3,4),(-1,-1)])))
+ pass
+
+ def testSwig2Intersect2DMeshWith1DLine13(self):
+ """ A square (side length) in a circle intersected by a simple horizontal line """
+ import math
+ eps = 1.0e-8
+ m = MEDCouplingUMesh("boxcircle", 2)
+ sq2 = math.sqrt(2.0)
+ soth = (sq2+1.0)/2.0
+ coo = [2., 0., sq2, sq2, 0., 2., -sq2, sq2, -2., 0., -sq2, -sq2, 0., -2., sq2, -sq2, -1., -1., -1., 1., 1.,
+ 1., 1., -1., -1., 0., 0., 1., 1., 0., 0., -1., -soth, soth, soth,soth]
+ coo = DataArrayDouble(coo); coo.rearrange(2)
+ m.setCoords(coo)
+ c = [NORM_QPOLYG, 8, 9, 10, 11, 12, 13, 14, 15, NORM_QPOLYG, 3, 1, 10, 9, 2, 17, 13, 16, NORM_QPOLYG, 1, 7, 5, 3, 9, 8, 11, 10, 0, 6, 4, 16, 12, 15, 14, 17]
+ cI = [0, 9, 18, 35]
+ m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
+ m.checkCoherency()
+ coords2 = [-2., 1., 2., 1.0]
+ connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
+ m_line = MEDCouplingUMesh("seg", 1)
+ m_line.setCoords(DataArrayDouble(coords2, len(coords2)/2, 2))
+ m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
+ a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
+ self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(2.,0.),(1.4142135623730951,1.4142135623730951),(0.,2.),(-1.4142135623730951,1.4142135623730951),(-2.,0.),(-1.4142135623730951,-1.4142135623730951),(0.,-2.),(1.4142135623730951,-1.4142135623730951),(-1.,-1.),(-1.,1.),(1.,1.),(1.,-1.),(-1.,0.),(0.,1.),(1.,0.),(0.,-1.),(-1.2071067811865475,1.2071067811865475),(1.2071067811865475,1.2071067811865475),(-2.,1.),(2.,1.),(1.7320508075688772,1.),(-1.7320508075688772,1.),(-1.2071067811865475,1.2071067811865475),(-1.3660254037844386,1.),(-1.58670668058247,1.2175228580174415),(0.,-1.),(1.,0.),(1.2071067811865475,1.2071067811865475),(1.5867066805824703,1.2175228580174413),(1.9828897227476205,-0.26105238444010315),(0.,-2.),(-1.9828897227476205,-0.2610523844401032),(-1.3660254037844386,1.),(-1.,0.),(1.5867066805824703,1.2175228580174413),(1.3660254037844386,1.),(1.2071067811865475,1.2071067811865475),(0.,-2.),(-1.9828897227476205,-0.2610523844401032),(-1.3660254037844386,1.),(-1.,0.),(0.,-1.),(1.,0.),(1.3660254037844386,1.),(1.9828897227476205,-0.26105238444010315)]),1e-12))
+ self.assertEqual([32,8,9,10,11,12,13,14,15,32,3,1,10,9,2,17,13,16,32,3,9,21,22,23,24,32,1,20,10,34,35,36,32,7,5,21,9,8,11,10,20,37,38,39,40,41,42,43,44],a.getNodalConnectivity().getValues())
+ self.assertEqual([0,9,18,25,32,49],a.getNodalConnectivityIndex().getValues())
+ self.assertEqual([1,18,21,1,21,9,1,9,10,1,10,20,1,20,19],b.getNodalConnectivity().getValues())
+ self.assertEqual([0,3,6,9,12,15],b.getNodalConnectivityIndex().getValues())
+ self.assertTrue(c.isEqual(DataArrayInt([0,1,2,2,2])))
+ self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(2,4),(1,0),(3,4),(-1,-1)])))
+ pass
+
+ def testSwig2Intersect2DMeshWith1DLine14(self):
+ """ A circle in a circle intersected by a simple horizontal line, not tangent to the circles """
+ eps = 1.0e-8
+ m = MEDCouplingUMesh("boxcircle", 2)
+ coo = [2.,0.,1.4142135623730951,1.414213562373095,0.,2.,-1.414213562373095,1.4142135623730951,-2.,0.,-1.4142135623730954,-1.414213562373095,0.,-2.,
+ 1.4142135623730947,-1.4142135623730954,1.,0.,0.7071067811865476,0.7071067811865475,0.,1.,-0.7071067811865475,0.7071067811865476,-1.,0.,-0.7071067811865477,-0.7071067811865475,
+ 0.,-1.,0.7071067811865474,-0.7071067811865477,1.060660171779821,-1.0606601717798214,-1.0606601717798214,-1.0606601717798212]
+ coo = DataArrayDouble(coo); coo.rearrange(2)
+ m.setCoords(coo)
+ c = [NORM_QPOLYG, 15, 13, 11, 9, 14, 12, 10, 8, NORM_QPOLYG, 7, 5, 13, 15, 6, 17, 14, 16, NORM_QPOLYG, 5, 3, 1, 7, 15, 9, 11, 13, 4, 2, 0, 16, 8, 10, 12, 17]
+ cI = [0, 9, 18, 35]
+ m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
+ m.checkCoherency()
+ coords2 = [-2., 0., 2., 0.]
+ connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
+ m_line = MEDCouplingUMesh.New("seg", 1)
+ m_line.setCoords(DataArrayDouble(coords2, len(coords2)/2, 2))
+ m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
+ a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
+ self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(2.,0.),(1.4142135623730951,1.414213562373095),(0.,2.),(-1.414213562373095,1.4142135623730951),(-2.,0.),(-1.4142135623730954,-1.414213562373095),(0.,-2.),(1.4142135623730947,-1.4142135623730954),(1.,0.),(0.7071067811865476,0.7071067811865475),(0.,1.),(-0.7071067811865475,0.7071067811865476),(-1.,0.),(-0.7071067811865477,-0.7071067811865475),(0.,-1.),(0.7071067811865474,-0.7071067811865477),(1.060660171779821,-1.0606601717798214),(-1.0606601717798214,-1.0606601717798212),(-2.,0.),(2.,0.),(-1.,0.),(1.,0.),(0.,2.),(1.8477590650225735,0.7653668647301795),(1.8477590650225735,-0.7653668647301797),(1.060660171779821,-1.0606601717798214),(0.9238795325112867,-0.38268343236508984),(0.9238795325112867,0.3826834323650897),(0.,1.),(-0.9238795325112867,0.3826834323650896),(-1.5,0.),(-1.8477590650225735,0.7653668647301792),(-1.0606601717798214,-1.0606601717798212),(-1.8477590650225733,-0.7653668647301799),(-1.5,0.),(-0.9238795325112866,-0.38268343236508995),(0.,1.),(-0.9238795325112867,0.3826834323650896),(-1.5,0.),(-1.8477590650225735,0.7653668647301792),(0.,2.),(1.8477590650225735,0.7653668647301795),(1.5,0.),(0.9238795325112867,0.3826834323650897),(1.060660171779821,-1.0606601717798214),(0.9238795325112867,-0.38268343236508984),(1.5,0.),(1.8477590650225735,-0.7653668647301797),(0.,1.),(0.9238795325112867,0.3826834323650897),(0.,0.),(-0.9238795325112867,0.3826834323650896),(0.,-1.),(-0.9238795325112866,-0.38268343236508995),(0.,0.),(0.9238795325112867,-0.38268343236508984)]),1e-12))
+ self.assertEqual([32,7,5,13,15,6,17,14,16,32,9,11,20,18,3,1,19,21,36,37,38,39,40,41,42,43,32,7,15,21,19,44,45,46,47,32,13,5,18,20,32,33,34,35,32,11,9,21,20,48,49,50,51,32,15,13,20,21,52,53,54,55],a.getNodalConnectivity().getValues())
+ self.assertEqual([0,9,26,35,44,53,62],a.getNodalConnectivityIndex().getValues())
+ self.assertEqual([1,18,20,1,20,21,1,21,19],b.getNodalConnectivity().getValues())
+ self.assertEqual([0,3,6,9],b.getNodalConnectivityIndex().getValues())
+ self.assertTrue(c.isEqual(DataArrayInt([1,2,2,2,0,0])))
+ self.assertTrue(d.isEqual(DataArrayInt([(1,3),(4,5),(1,2)])))
+ pass
+
+ def testSwig2Intersect2DMeshWith1DLine15(self):
+ """ Same as testSwig2Intersect2DMeshWith1DLine13 except that the line is colinear AND splits on of the common edge of 2D mesh."""
+ import math
+ eps = 1.0e-8
+ m = MEDCouplingUMesh("boxcircle", 2)
+ sq2 = math.sqrt(2.0)
+ soth = (sq2+1.0)/2.0
+ coo = [2., 0., sq2, sq2, 0., 2., -sq2, sq2, -2., 0., -sq2, -sq2, 0., -2., sq2, -sq2, -1., -1., -1., 1., 1.,
+ 1., 1., -1., -1., 0., 0., 1., 1., 0., 0., -1., -soth, soth, soth,soth]
+ coo = DataArrayDouble(coo); coo.rearrange(2)
+ m.setCoords(coo)
+ c = [NORM_QPOLYG, 8, 9, 10, 11, 12, 13, 14, 15, NORM_QPOLYG, 3, 1, 10, 9, 2, 17, 13, 16, NORM_QPOLYG, 1, 7, 5, 3, 9, 8, 11, 10, 0, 6, 4, 16, 12, 15, 14, 17]
+ cI = [0, 9, 18, 35]
+ m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
+ m.checkCoherency()
+ coords2 = [(-2., 1.),(2.,1.),(0.,1)]
+ connec2, cI2 = [NORM_SEG2, 0, 2, NORM_SEG2, 2, 1], [0,3,6]
+ m_line = MEDCouplingUMesh("seg", 1)
+ m_line.setCoords(DataArrayDouble(coords2))
+ m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
+ a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
+ self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(2.,0.),(1.4142135623730951,1.4142135623730951),(0.,2.),(-1.4142135623730951,1.4142135623730951),(-2.,0.),(-1.4142135623730951,-1.4142135623730951),(0.,-2.),(1.4142135623730951,-1.4142135623730951),(-1.,-1.),(-1.,1.),(1.,1.),(1.,-1.),(-1.,0.),(0.,1.),(1.,0.),(0.,-1.),(-1.2071067811865475,1.2071067811865475),(1.2071067811865475,1.2071067811865475),(-2.,1.),(2.,1.),(0.,1.),(1.7320508075688776,1.),(-1.7320508075688776,1.),(-0.5,1.),(0.5,1.),(0.5,1.),(-0.5,1.),(-1.2071067811865475,1.2071067811865475),(-1.3660254037844388,1.),(-1.58670668058247,1.2175228580174415),(0.,-1.),(1.,0.),(1.2071067811865475,1.2071067811865475),(1.5867066805824703,1.2175228580174413),(1.9828897227476205,-0.26105238444010315),(0.,-2.),(-1.9828897227476205,-0.2610523844401032),(-1.3660254037844388,1.),(-1.,0.),(1.5867066805824703,1.2175228580174413),(1.3660254037844388,1.),(1.2071067811865475,1.2071067811865475),(0.,-2.),(-1.9828897227476205,-0.2610523844401032),(-1.3660254037844388,1.),(-1.,0.),(0.,-1.),(1.,0.),(1.3660254037844388,1.),(1.9828897227476205,-0.26105238444010315)]),1e-12))
+ self.assertEqual([32,8,9,20,10,11,12,23,24,14,15,32,3,1,10,20,9,2,17,25,26,16,32,3,9,22,27,28,29,32,1,21,10,39,40,41,32,7,5,22,9,8,11,10,21,42,43,44,45,46,47,48,49],a.getNodalConnectivity().getValues())
+ self.assertEqual([0,11,22,29,36,53],a.getNodalConnectivityIndex().getValues())
+ self.assertEqual([1,18,22,1,22,9,1,9,20,1,20,10,1,10,21,1,21,19],b.getNodalConnectivity().getValues())
+ self.assertEqual([0,3,6,9,12,15,18],b.getNodalConnectivityIndex().getValues())
+ self.assertTrue(c.isEqual(DataArrayInt([0,1,2,2,2])))
+ self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(2,4),(1,0),(1,0),(3,4),(-1,-1)])))
+ pass
+
+ def testSwig2Intersect2DMeshWith1DLine16(self):
+ """ Same than testSwig2Intersect2DMeshWith1DLine13 except it is a vertical line. Non regression test."""
+ import math
+ eps = 1.0e-8
+ m = MEDCouplingUMesh("boxcircle", 2)
+ sq2 = math.sqrt(2.0)
+ soth = (sq2+1.0)/2.0
+ coo = [2., 0., sq2, sq2, 0., 2., -sq2, sq2, -2., 0., -sq2, -sq2, 0., -2., sq2, -sq2, -1., -1., -1., 1., 1.,
+ 1., 1., -1., -1., 0., 0., 1., 1., 0., 0., -1., -soth, soth, soth,soth]
+ coo = DataArrayDouble(coo); coo.rearrange(2)
+ m.setCoords(coo)
+ c = [NORM_QPOLYG, 8, 9, 10, 11, 12, 13, 14, 15, NORM_QPOLYG, 3, 1, 10, 9, 2, 17, 13, 16, NORM_QPOLYG, 1, 7, 5, 3, 9, 8, 11, 10, 0, 6, 4, 16, 12, 15, 14, 17]
+ cI = [0, 9, 18, 35]
+ m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
+ m.checkCoherency()
+ coords2 = [1., 2., 1., -2.]
+ connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
+ m_line = MEDCouplingUMesh("seg", 1)
+ m_line.setCoords(DataArrayDouble(coords2, len(coords2)/2, 2))
+ m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
+ a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
+ self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
+ self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
+ self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
+ self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(2., 0.),(1.4142135623730951,1.4142135623730951),(0.,2.),(-1.4142135623730951,1.4142135623730951),(-2.,0.),(-1.4142135623730951,-1.4142135623730951),(0.,-2.),(1.4142135623730951,-1.4142135623730951),(-1.,-1.),(-1.,1.),(1.,1.),(1.,-1.),(-1.,0.),(0.,1.),(1.,0.),(0.,-1.),(-1.2071067811865475,1.2071067811865475),(1.2071067811865475,1.2071067811865475),(1.,2.),(1.,-2.),(1.,1.7320508075688772),(1.,-1.7320508075688772),(1.2071067811865475,1.2071067811865475),(1.,1.3660254037844386),(1.217522858017441,1.5867066805824703),(-1.2071067811865475,1.2071067811865475),(-0.2610523844401028,1.9828897227476208),(1.,1.3660254037844386),(0.,1.),(1.2071067811865475,1.2071067811865475),(2.,0.),(1.217522858017441,-1.5867066805824703),(1.,-1.3660254037844386),(1.,0.),(-2.,0.),(-1.2071067811865475,1.2071067811865475),(-1.,0.),(0.,-1.),(1.,-1.3660254037844386),(-0.2610523844401028,-1.9828897227476208)]),1e-12))
+ self.assertEqual([32,8,9,10,11,12,13,14,15,32,1,10,20,22,23,24,32,9,3,20,10,25,26,27,28,32,10,1,7,21,11,29,30,31,32,33,32,5,3,9,8,11,21,34,35,36,37,38,39],a.getNodalConnectivity().getValues())
+ self.assertEqual([0,9,16,25,36,49],a.getNodalConnectivityIndex().getValues())
+ self.assertEqual([1,18,20,1,20,10,1,10,11,1,11,21,1,21,19],b.getNodalConnectivity().getValues())
+ self.assertEqual([0,3,6,9,12,15],b.getNodalConnectivityIndex().getValues())
+ self.assertTrue(c.isEqual(DataArrayInt([0,1,1,2,2])))
+ self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(3,0),(3,4),(-1,-1)])))
+ pass
+
+ def testOrderConsecutiveCells1D1(self):
+ """A line in several unconnected pieces:"""
+ m2 = MEDCouplingUMesh.New("bla", 1)
+ c = DataArrayInt([NORM_SEG2,0,1,NORM_SEG3,1,3,2, NORM_SEG2,3,4,
+ NORM_SEG3,5,7,6, NORM_SEG3,7,9,8, NORM_SEG2,9,10,
+ NORM_SEG2,11,12,NORM_SEG2,12,13,
+ NORM_SEG2,14,15])
+ cI = DataArrayInt([0,3,7,10,14,18,21,24,27,30])
+ coords2 = DataArrayDouble([float(i) for i in range(32)], 16,2)
+ m2.setCoords(coords2);
+ m2.setConnectivity(c, cI);
+ m2.checkCoherency2(1.0e-8);
+
+ # Shuffle a bit :-)
+ m2.renumberCells(DataArrayInt([0,3,6,8,1,4,7,5,2]), True);
+ res = m2.orderConsecutiveCells1D()
+ expRes = [0,3,6,8,1,4,2,7,5]
+ self.assertEqual(m2.getNumberOfCells(),res.getNumberOfTuples())
+ self.assertEqual(expRes, res.getValues())
+
+ # A closed line (should also work)
+ m3 = MEDCouplingUMesh.New("bla3", 1)
+ conn3A = DataArrayInt([NORM_SEG2,0,1,NORM_SEG3,1,3,2, NORM_SEG2,3,0])
+ coord3 = coords2[0:5]
+ c.reAlloc(10)
+ cI.reAlloc(4)
+
+ m3.setCoords(coord3)
+ m3.setConnectivity(conn3A, cI)
+ m3.checkCoherency2(1.0e-8)
+ res2 = m3.orderConsecutiveCells1D()
+ expRes2 = [0,1,2]
+ self.assertEqual(m3.getNumberOfCells(),res2.getNumberOfTuples())
+ self.assertEqual(expRes2, res2.getValues())
+ pass
+
+ def testDADApplyFuncOnThis1(self):
+ d=DataArrayDouble(5) ; d.iota(0.)
+ d.applyFuncOnThis("2*x+1")
+ self.assertTrue(d.isEqual(DataArrayDouble([1.,3.,5.,7.,9.]),1e-12))
+ d=DataArrayDouble(6) ; d.iota(0.) ; d.rearrange(2)
+ d.applyFuncOnThis("2*x+1")
+ self.assertTrue(d.isEqual(DataArrayDouble([1.,3.,5.,7.,9.,11.],3,2),1e-12))
+ d.applyFuncOnThis("1+2*3")
+ self.assertTrue(d.isEqual(DataArrayDouble([(7.,7.),(7.,7.),(7.,7.)]),1e-12))
+ pass
+
+ def testSwig2PointSetComputeFetchedNodeIds1(self):
+ arr=DataArrayDouble(6) ; arr.iota()
+ m=MEDCouplingCMesh() ; m.setCoords(arr,arr,arr)
+ m=m.buildUnstructured()
+ m0=m[[0,1,5,6,25,26,30,31,124]]
+ ref=DataArrayInt([0,1,2,6,7,8,12,13,14,36,37,38,42,43,44,48,49,50,72,73,74,78,79,80,84,85,86,172,173,178,179,208,209,214,215])
+ self.assertTrue(m0.computeFetchedNodeIds().isEqual(ref))
+ self.assertTrue(MEDCoupling1SGTUMesh(m0).computeFetchedNodeIds().isEqual(ref))
+ self.assertEqual(m0.getAllGeoTypes(),[NORM_HEXA8])
+ m0.convertAllToPoly()
+ self.assertEqual(m0.getAllGeoTypes(),[NORM_POLYHED])
+ self.assertTrue(MEDCoupling1DGTUMesh(m0).computeFetchedNodeIds().isEqual(ref))
+ pass
+
+ def testSwig2PartDefinition1(self):
+ pd=PartDefinition.New(5,22,3)
+ self.assertTrue(isinstance(pd,SlicePartDefinition))
+ self.assertTrue(pd.toDAI().isEqual(DataArrayInt([5,8,11,14,17,20])))
+ self.assertEqual(pd.getNumberOfElems(),6)
+ self.assertEqual(pd.getEffectiveStop(),23)
+ pd=PartDefinition.New(5,23,3)
+ self.assertTrue(isinstance(pd,SlicePartDefinition))
+ self.assertTrue(pd.toDAI().isEqual(DataArrayInt([5,8,11,14,17,20])))
+ self.assertEqual(pd.getNumberOfElems(),6)
+ self.assertEqual(pd.getEffectiveStop(),23)
+ self.assertEqual(pd.getSlice(),slice(5,23,3))
+ pd=PartDefinition.New(5,22,1)
+ self.assertTrue(isinstance(pd,SlicePartDefinition))
+ self.assertTrue(pd.toDAI().isEqual(DataArrayInt([5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21])))
+ self.assertEqual(pd.getNumberOfElems(),17)
+ self.assertEqual(pd.getEffectiveStop(),22)
+ pd=PartDefinition.New(5,23,3)+PartDefinition.New(23,27,3)
+ self.assertTrue(isinstance(pd,SlicePartDefinition))
+ self.assertEqual(pd.getNumberOfElems(),8)
+ self.assertTrue(pd.toDAI().isEqual(DataArrayInt([5,8,11,14,17,20,23,26])))
+ self.assertEqual(pd.getEffectiveStop(),29)
+ pd=SlicePartDefinition(5,22,1)
+ self.assertTrue(isinstance(pd,SlicePartDefinition))
+ self.assertTrue(pd.toDAI().isEqual(DataArrayInt([5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21])))
+ self.assertEqual(pd.getNumberOfElems(),17)
+ self.assertEqual(pd.getEffectiveStop(),22)
+ d=DataArrayInt([2,4,5,6,10])
+ pd=PartDefinition.New(d)
+ self.assertTrue(isinstance(pd,DataArrayPartDefinition))
+ self.assertEqual(pd.toDAI().getHiddenCppPointer(),d.getHiddenCppPointer())
+ pd=DataArrayPartDefinition(d)
+ self.assertEqual(pd.toDAI().getHiddenCppPointer(),d.getHiddenCppPointer())
+ pd=DataArrayPartDefinition(d)+DataArrayPartDefinition(DataArrayInt([12,14,20]))
+ self.assertTrue(isinstance(pd,DataArrayPartDefinition))
+ self.assertEqual(pd.getNumberOfElems(),8)
+ self.assertTrue(pd.toDAI().isEqual(DataArrayInt([2,4,5,6,10,12,14,20])))
+ pass
+
+ def testSwig2SortEachPairToMakeALinkedList1(self):
+ d=DataArrayInt([(50,49),(50,51),(51,52),(53,52),(53,54),(55,54),(55,56),(56,57),(58,57),(58,59),(60,59),(60,61),(61,62),(63,62),(63,64),(65,64),(65,66),(66,67)])
+ d.sortEachPairToMakeALinkedList()
+ self.assertTrue(d.isEqual(DataArrayInt([(49,50),(50,51),(51,52),(52,53),(53,54),(54,55),(55,56),(56,57),(57,58),(58,59),(59,60),(60,61),(61,62),(62,63),(63,64),(64,65),(65,66),(66,67)])))
+ pass
+
+ def testSwig2DAIIsRange(self):
+ d=DataArrayInt([2,6,10])
+ a,b=d.isRange()
+ self.assertTrue(a)
+ self.assertEqual(b,slice(2,11,4))
+ self.assertTrue(DataArrayInt.Range(b.start,b.stop,b.step).isEqual(d))
+ #
+ d=DataArrayInt([2,7,10])
+ a,b=d.isRange()
+ self.assertTrue(not a)
+ self.assertTrue(b is None)
+ #
+ d=DataArrayInt([22,17,12])
+ a,b=d.isRange()
+ self.assertTrue(a)
+ self.assertEqual(b,slice(22,11,-5))
+ self.assertTrue(DataArrayInt.Range(b.start,b.stop,b.step).isEqual(d))
+ #
+ d=DataArrayInt([22,16,12])
+ a,b=d.isRange()
+ self.assertTrue(not a)
+ self.assertTrue(b is None)
+ #
+ d=DataArrayInt([33])
+ a,b=d.isRange()
+ self.assertTrue(a)
+ self.assertEqual(b,slice(33,34,1))
+ self.assertTrue(DataArrayInt.Range(b.start,b.stop,b.step).isEqual(d))
+ #
+ d=DataArrayInt([])
+ a,b=d.isRange()
+ self.assertTrue(a)
+ self.assertEqual(b,slice(0,0,1))
+ self.assertTrue(DataArrayInt.Range(b.start,b.stop,b.step).isEqual(d))
+ #
+ d=DataArrayInt([2,6,10,2])
+ a,b=d.isRange()
+ self.assertTrue(not a)
+ self.assertTrue(b is None)
+ pass
+
+ def testSwig2PartDefinitionComposeWith1(self):
+ f=PartDefinition.New(DataArrayInt([0,1,2,3,6,7,8,9]))
+ g=PartDefinition.New(4,14,1)
+ g2=g.deepCpy()
+ self.assertTrue(g2.isEqual(g)[0])
+ h=f.composeWith(g)
+ self.assertTrue(isinstance(h,DataArrayPartDefinition))
+ self.assertTrue(h.toDAI().isEqual(DataArrayInt([4,5,6,7,10,11,12,13])))
+ f2=f.tryToSimplify()
+ g2=g.tryToSimplify()
+ self.assertEqual(f2.getHiddenCppPointer(),f.getHiddenCppPointer())# same because no simplification due to content of array
+ self.assertEqual(g2.getHiddenCppPointer(),g.getHiddenCppPointer())# same because no simplification linked to type of PartDef
+ p=PartDefinition.New(DataArrayInt([2,6,10]))
+ p2=p.tryToSimplify()
+ self.assertNotEqual(p2.getHiddenCppPointer(),p.getHiddenCppPointer())
+ self.assertTrue(isinstance(p2,SlicePartDefinition))
+ self.assertEqual(p2.getSlice(),slice(2,11,4))
+ self.assertTrue(p2.isEqual(SlicePartDefinition(2,11,4))[0])
+ self.assertTrue(p2.isEqual(p2.deepCpy())[0])
+ self.assertTrue(not p2.isEqual(SlicePartDefinition(1,11,4))[0])
+ self.assertTrue(not p2.isEqual(SlicePartDefinition(2,10,4))[0])
+ self.assertTrue(not p2.isEqual(SlicePartDefinition(2,11,3))[0])
+ pass
+
+ def testSwig2DAIGetIdsStrictlyNegative1(self):
+ d=DataArrayInt([4,-5,-1,0,3,99,-7])
+ self.assertTrue(d.getIdsStrictlyNegative().isEqual(DataArrayInt([1,2,6])))
+ pass
+
+ def testSwig2DAIReplaceOneValByInThis1(self):
+ d=DataArrayInt([4,-5,-1,0,-5,99,-7,5])
+ d.replaceOneValByInThis(-5,900)
+ self.assertTrue(d.isEqual(DataArrayInt([4,900,-1,0,900,99,-7,5])))
+ pass
+
+ def testSwig2DAIGetMinMaxValues1(self):
+ d=DataArrayInt([4,-5,-1,0,3,99,-7])
+ a,b=d.getMinMaxValues()
+ self.assertEqual(a,-7)
+ self.assertEqual(b,99)
+ pass
+
+ def testSwig2DAIBuildUniqueNotSorted1(self):
+ d=DataArrayInt([-5,3,2,-1,2,3,-6,4,2,-5,3,7])
+ self.assertTrue(d.buildUniqueNotSorted().isEqual(DataArrayInt([-5,3,2,-1,-6,4,7])))
+ pass
+
+ def testSwig2UMeshChangeOrientationOfCells1(self):
+ """ Here testing changeOrientationOfCell method on unstructured meshes lying on no coords."""
+ m=MEDCouplingUMesh("mesh",1)
+ c=DataArrayInt([NORM_SEG2,4,5,NORM_SEG2,10,8,NORM_SEG3,20,7,33,NORM_SEG3,13,15,12,NORM_SEG2,3,2,NORM_SEG4,5,6,8,10,NORM_SEG4,34,33,3,2])
+ cI=DataArrayInt([0,3,6,10,14,17,22,27])
+ m.setConnectivity(c,cI)
+ m.changeOrientationOfCells()
+ self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([NORM_SEG2,5,4,NORM_SEG2,8,10,NORM_SEG3,7,20,33,NORM_SEG3,15,13,12,NORM_SEG2,2,3,NORM_SEG4,6,5,10,8,NORM_SEG4,33,34,2,3])))
+ self.assertTrue(m.getNodalConnectivityIndex().isEqual(cI))
+ # testing 2D cells
+ m=MEDCouplingUMesh("mesh",2)
+ c=DataArrayInt([NORM_TRI3,0,1,2,NORM_QUAD4,3,4,5,6,NORM_POLYGON,7,8,9,10,11,NORM_TRI6,12,13,14,15,16,17,NORM_QUAD8,18,19,20,21,22,23,24,25,NORM_QPOLYG,26,27,28,29,30,31,32,33,34,35])
+ cI=DataArrayInt([0,4,9,15,22,31,42])
+ m.setConnectivity(c,cI)
+ m.changeOrientationOfCells()
+ self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([NORM_TRI3,0,2,1,NORM_QUAD4,3,6,5,4,NORM_POLYGON,7,11,10,9,8,NORM_TRI6,12,14,13,17,16,15,NORM_QUAD8,18,21,20,19,25,24,23,22,NORM_QPOLYG,26,30,29,28,27,35,34,33,32,31])))
+ self.assertTrue(m.getNodalConnectivityIndex().isEqual(cI))
+ pass
+
+ def testSwig2StructuredMeshCellLocation1(self):
+ # 3D
+ arrX=DataArrayDouble(5) ; arrX.iota()
+ arrY=DataArrayDouble(4) ; arrY.iota()
+ arrZ=DataArrayDouble(3) ; arrZ.iota()
+ m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ)
+ li=[]
+ liExp3D=[(0,0,0),(1,0,0),(2,0,0),(3,0,0),(0,1,0),(1,1,0),(2,1,0),(3,1,0),(0,2,0),(1,2,0),(2,2,0),(3,2,0),(0,0,1),(1,0,1),(2,0,1),(3,0,1),(0,1,1),(1,1,1),(2,1,1),(3,1,1),(0,2,1),(1,2,1),(2,2,1),(3,2,1)]
+ self.assertEqual(24,m.getNumberOfCells())
+ for i in xrange(m.getNumberOfCells()):
+ li.append(m.getLocationFromCellId(i))
+ pass
+ self.assertEqual(liExp3D,li)
+ self.assertRaises(InterpKernelException,m.getLocationFromCellId,24)
+ self.assertRaises(InterpKernelException,m.getLocationFromCellId,-1)
+ # 2D
+ arrX=DataArrayDouble(5) ; arrX.iota()
+ arrY=DataArrayDouble(4) ; arrY.iota()
+ m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY)
+ li=[]
+ liExp2D=[(0,0),(1,0),(2,0),(3,0),(0,1),(1,1),(2,1),(3,1),(0,2),(1,2),(2,2),(3,2)]
+ self.assertEqual(12,m.getNumberOfCells())
+ for i in xrange(m.getNumberOfCells()):
+ li.append(m.getLocationFromCellId(i))
+ pass
+ self.assertEqual(liExp2D,li)
+ self.assertRaises(InterpKernelException,m.getLocationFromCellId,12)
+ self.assertRaises(InterpKernelException,m.getLocationFromCellId,-1)
+ # 1D
+ arrX=DataArrayDouble(5) ; arrX.iota()
+ m=MEDCouplingCMesh() ; m.setCoords(arrX)
+ self.assertEqual(4,m.getNumberOfCells())
+ for i in xrange(m.getNumberOfCells()):
+ self.assertEqual((i,),m.getLocationFromCellId(i))
+ pass
+ self.assertRaises(InterpKernelException,m.getLocationFromCellId,4)
+ self.assertRaises(InterpKernelException,m.getLocationFromCellId,-1)
+ pass
+
+ def testSwig2StructuredMeshNodeLocation1(self):
+ # 3D
+ arrX=DataArrayDouble(5) ; arrX.iota()
+ arrY=DataArrayDouble(4) ; arrY.iota()
+ arrZ=DataArrayDouble(3) ; arrZ.iota()
+ m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ)
+ li=[]
+ liExp3D=[(0,0,0),(1,0,0),(2,0,0),(3,0,0),(4,0,0),(0,1,0),(1,1,0),(2,1,0),(3,1,0),(4,1,0),(0,2,0),(1,2,0),(2,2,0),(3,2,0),(4,2,0),(0,3,0),(1,3,0),(2,3,0),(3,3,0),(4,3,0),(0,0,1),(1,0,1),(2,0,1),(3,0,1),(4,0,1),(0,1,1),(1,1,1),(2,1,1),(3,1,1),(4,1,1),(0,2,1),(1,2,1),(2,2,1),(3,2,1),(4,2,1),(0,3,1),(1,3,1),(2,3,1),(3,3,1),(4,3,1),(0,0,2),(1,0,2),(2,0,2),(3,0,2),(4,0,2),(0,1,2),(1,1,2),(2,1,2),(3,1,2),(4,1,2),(0,2,2),(1,2,2),(2,2,2),(3,2,2),(4,2,2),(0,3,2),(1,3,2),(2,3,2),(3,3,2),(4,3,2)]
+ self.assertEqual(60,m.getNumberOfNodes())
+ for i in xrange(m.getNumberOfNodes()):
+ li.append(m.getLocationFromNodeId(i))
+ pass
+ self.assertEqual(liExp3D,li)
+ self.assertRaises(InterpKernelException,m.getLocationFromNodeId,60)
+ self.assertRaises(InterpKernelException,m.getLocationFromNodeId,-1)
+ # 2D
+ arrX=DataArrayDouble(5) ; arrX.iota()
+ arrY=DataArrayDouble(4) ; arrY.iota()
+ m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY)
+ li=[]
+ liExp2D=[(0,0),(1,0),(2,0),(3,0),(4,0),(0,1),(1,1),(2,1),(3,1),(4,1),(0,2),(1,2),(2,2),(3,2),(4,2),(0,3),(1,3),(2,3),(3,3),(4,3)]
+ self.assertEqual(20,m.getNumberOfNodes())
+ for i in xrange(m.getNumberOfNodes()):
+ li.append(m.getLocationFromNodeId(i))
+ pass
+ self.assertEqual(liExp2D,li)
+ self.assertRaises(InterpKernelException,m.getLocationFromNodeId,20)
+ self.assertRaises(InterpKernelException,m.getLocationFromNodeId,-1)
+ # 1D
+ arrX=DataArrayDouble(5) ; arrX.iota()
+ m=MEDCouplingCMesh() ; m.setCoords(arrX)
+ self.assertEqual(5,m.getNumberOfNodes())
+ for i in xrange(m.getNumberOfNodes()):
+ self.assertEqual((i,),m.getLocationFromNodeId(i))
+ pass
+ self.assertRaises(InterpKernelException,m.getLocationFromCellId,5)
+ self.assertRaises(InterpKernelException,m.getLocationFromCellId,-1)
+ pass
+
+ def testSwig2DataArrayPrintNotTooLong1(self):
+ """ Now that DataArrayDouble and DataArrayInt and pickelized they can appear in YACS ports. Avoid to have too heavy string representation of them."""
+ d=DataArrayDouble(2000) ; d.iota() ; d.rearrange(2)
+ st0=d.repr() ; st1=str(d) ; st2=d.reprNotTooLong()
+ self.assertEqual(st0,st1) # 1000 tuples ( >=0 and <= 1000) -> str(d)==d.repr()
+ self.assertEqual(st1,st2)
+ #
+ d=DataArrayDouble(2002) ; d.iota() ; d.rearrange(2)
+ st0=d.repr() ; st1=str(d) ; st2=d.reprNotTooLong()
+ self.assertNotEqual(st0,st1) # 1001 tuples ( > 1000) -> str(d)==d.reprNotTooLong()
+ self.assertEqual(st1,st2)
+ self.assertIn(len(st2),xrange(0,1000)) # no more than 1000 characters
+ ## Now for DataArrayInt
+ d=DataArrayInt(2000) ; d.iota() ; d.rearrange(2)
+ st0=d.repr() ; st1=str(d) ; st2=d.reprNotTooLong()
+ self.assertEqual(st0,st1) # 1000 tuples ( >=0 and <= 1000) -> str(d)==d.repr()
+ self.assertEqual(st1,st2)
+ #
+ d=DataArrayInt(2002) ; d.iota() ; d.rearrange(2)
+ st0=d.repr() ; st1=str(d) ; st2=d.reprNotTooLong()
+ self.assertNotEqual(st0,st1) # 1001 tuples ( > 1000) -> str(d)==d.reprNotTooLong()
+ self.assertEqual(st1,st2)
+ self.assertIn(len(st2),xrange(0,1000)) # no more than 1000 characters
+ pass
+
+ def testExtrudedMeshWithoutZipCoords1(self):
+ """This test checks that MEDCouplingUMesh.buildExtrudedMesh do not perform a zipCoords."""
+ arr=DataArrayDouble([(0.,0.),(1.,0.),(2.,0.),(3.,0.)])
+ m=MEDCouplingUMesh("mesh",1) ; m.setCoords(arr)
+ m.allocateCells()
+ m.insertNextCell(NORM_SEG2,[1,2])
+ arr1D=DataArrayDouble([(0.,0.),(0.,1.5),(0.,2.)])
+ m1D=MEDCouplingUMesh("mesh1D",1) ; m1D.setCoords(arr1D)
+ m1D.allocateCells()
+ m1D.insertNextCell(NORM_SEG2,[0,1])
+ m1D.insertNextCell(NORM_SEG2,[1,2])
+ m2D=m.buildExtrudedMesh(m1D,0)
+ self.assertEqual(m.getCoords().getHiddenCppPointer(),m2D.getCoords().getHiddenCppPointer())
+ coo=DataArrayDouble([(0,0),(1,0),(2,0),(3,0),(0,1.5),(1,1.5),(2,1.5),(3,1.5),(0,2),(1,2),(2,2),(3,2)])
+ self.assertTrue(m.getCoords().isEqual(coo,1e-12))
+ self.assertTrue(m2D.getNodalConnectivity().isEqual(DataArrayInt([4,1,2,6,5,4,5,6,10,9])))
+ self.assertTrue(m2D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10])))
+ pass
+
+ def testPointSetAreAllNodesFetched1(self):
+ m=MEDCouplingCMesh() ; arr=DataArrayDouble(10) ; arr.iota()
+ m.setCoords(arr,arr)
+ m=m.buildUnstructured()
+ self.assertTrue(m.areAllNodesFetched())
+ m2=m[[0,2,3,4,5]]
+ self.assertTrue(not m2.areAllNodesFetched())
+ m2.zipCoords()
+ self.assertTrue(m2.areAllNodesFetched())
+ pass
+
+ def testMEDCouplingPointSetComputeDiameterField1(self):
+ arrX=DataArrayDouble([0.,1.1,1.7,2.1])
+ arrY=DataArrayDouble([0.,0.7,0.8,1.9])
+ arrZ=DataArrayDouble([0.,1.3,2.1,2.4])
+ m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ) ; m=m.buildUnstructured()
+ f=m.computeDiameterField()
+ f.checkCoherency()
+ exp=DataArrayDouble([1.8411952639521971,1.5937377450509227,1.5297058540778357,1.705872210923198,1.4352700094407325,1.3638181696985856,2.0273134932713295,1.8055470085267789,1.7492855684535902,1.5297058540778357,1.2206555615733703,1.1357816691600546,1.3638181696985856,1.004987562112089,0.9,1.7492855684535902,1.4866068747318506,1.4177446878757824,1.3379088160259651,0.9695359714832656,0.8602325267042626,1.1445523142259597,0.6782329983125266,0.5099019513592785,1.5842979517754858,1.2884098726725124,1.208304597359457])
+ self.assertTrue(exp.isEqual(f.getArray(),1e-12))
+ m1=m[::2]
+ m2=m[1::2]
+ m2.simplexize(PLANAR_FACE_5)
+ m3=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m1,m2)
+ f=m3.computeDiameterField()
+ f.checkCoherency()
+ exp2=DataArrayDouble([1.8411952639521971,1.5297058540778357,1.4352700094407325,2.0273134932713295,1.7492855684535902,1.2206555615733703,1.3638181696985856,0.9,1.4866068747318506,1.3379088160259651,0.8602325267042626,0.6782329983125266,1.5842979517754858,1.208304597359457,1.47648230602334,1.47648230602334,1.47648230602334,1.47648230602334,1.47648230602334,1.7029386365926402,1.7029386365926402,1.7029386365926402,1.7029386365926402,1.7029386365926402,1.3601470508735445,1.3601470508735445,1.3601470508735445,1.3601470508735445,1.3601470508735445,1.70293863659264,1.70293863659264,1.70293863659264,1.70293863659264,1.70293863659264,1.3601470508735445,1.3601470508735445,1.3601470508735445,1.3601470508735445,1.3601470508735445,1.063014581273465,1.063014581273465,1.063014581273465,1.063014581273465,1.063014581273465,1.0,1.0,1.0,1.0,1.0,1.5556349186104046,1.5556349186104046,1.5556349186104046,1.5556349186104046,1.5556349186104046,1.3601470508735443,1.3601470508735443,1.3601470508735443,1.3601470508735443,1.3601470508735443,0.9219544457292886,0.9219544457292886,0.9219544457292886,0.9219544457292886,0.9219544457292886,1.140175425099138,1.140175425099138,1.140175425099138,1.140175425099138,1.140175425099138,0.5,0.5,0.5,0.5,0.5,1.2529964086141667,1.2529964086141667,1.2529964086141667,1.2529964086141667,1.2529964086141667])
+ self.assertTrue(exp2.isEqual(f.getArray(),1e-12))
+ # TRI3 - spacedim = 2
+ coo=DataArrayDouble([(1,1),(5,1.9),(2.1,3)])
+ m=MEDCoupling1SGTUMesh("mesh",NORM_TRI3) ; m.setCoords(coo)
+ for c in [[0,1,2],[0,2,1],[2,1,0]]:
+ m.setNodalConnectivity(DataArrayInt(c))
+ self.assertAlmostEqual(m.computeDiameterField().getArray()[0],4.1,12)
+ m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
+ self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],4.1,12)
+ m3=m.buildUnstructured() ; m3.convertLinearCellsToQuadratic(1)
+ self.assertAlmostEqual(m3.computeDiameterField().getArray()[0],4.1,12)
+ # TRI3 - spacedim = 3
+ coo=DataArrayDouble([(1.3198537928820775,1.0991902391274959,-0.028645697595823361),(5.2486835106806335,2.2234012799688281,0.30368935050077939),(2.2973688139447361,3.1572023778066649,0.10937756365410012)])
+ m=MEDCoupling1SGTUMesh("mesh",NORM_TRI3) ; m.setCoords(coo)
+ for c in [[0,1,2],[0,2,1],[2,1,0]]:
+ m.setNodalConnectivity(DataArrayInt(c))
+ self.assertAlmostEqual(m.computeDiameterField().getArray()[0],4.1,12)
+ m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
+ self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],4.1,12)
+ m3=m.buildUnstructured() ; m3.convertLinearCellsToQuadratic(1)
+ self.assertAlmostEqual(m3.computeDiameterField().getArray()[0],4.1,12)
+ # QUAD4 - spacedim = 2
+ coo=DataArrayDouble([(0,2),(2,0),(6,4),(4,9)])
+ m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4) ; m.setCoords(coo)
+ exp3=sqrt(85.)
+ for delta in xrange(4):
+ c=[(elt+delta)%4 for elt in xrange(4)]
+ m.setNodalConnectivity(DataArrayInt(c))
+ self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp3,12)
+ m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
+ self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp3,12)
+ m3=m.buildUnstructured() ; m3.convertLinearCellsToQuadratic(1)
+ self.assertAlmostEqual(m3.computeDiameterField().getArray()[0],exp3,12)
+ c.reverse()
+ m.setNodalConnectivity(DataArrayInt(c))
+ self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp3,12)
+ m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
+ self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp3,12)
+ m3=m.buildUnstructured() ; m3.convertLinearCellsToQuadratic(1)
+ self.assertAlmostEqual(m3.computeDiameterField().getArray()[0],exp3,12)
+ # QUAD4 - spacedim = 3
+ coo=DataArrayDouble([(0.26570992384234871,2.0405889913271817,-0.079134238105786903),(2.3739976619218064,0.15779148692781009,0.021842842914139737),(6.1207841448393197,4.3755532938679655,0.43666375769970678),(3.8363255342943359,9.2521096041694229,0.41551170895942313)])
+ m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4) ; m.setCoords(coo)
+ for delta in xrange(4):
+ c=[(elt+delta)%4 for elt in xrange(4)]
+ m.setNodalConnectivity(DataArrayInt(c))
+ self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp3,12)
+ m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
+ self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp3,12)
+ m3=m.buildUnstructured() ; m3.convertLinearCellsToQuadratic(1)
+ self.assertAlmostEqual(m3.computeDiameterField().getArray()[0],exp3,12)
+ c.reverse()
+ m.setNodalConnectivity(DataArrayInt(c))
+ self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp3,12)
+ m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
+ self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp3,12)
+ m3=m.buildUnstructured() ; m3.convertLinearCellsToQuadratic(1)
+ self.assertAlmostEqual(m3.computeDiameterField().getArray()[0],exp3,12)
+ # PENTA6
+ # noise of coo=DataArrayDouble([(0,0,0),(1,0,0),(0,1,0),(0,0,2),(1,0,2),(0,1,2)]) + rotation([0.7,-1.2,0.6],[-4,-1,10],0.3)
+ coo=DataArrayDouble([(-0.28594726851554486,-0.23715005500928255,-0.10268080010083136),(0.6167364988633947,-0.008923258436324799,-0.08574087516687756),(-0.6132873463333834,0.6943403970881654,-0.2806118260037991),(-0.40705974936532896,-0.05868487929989308,1.7724055544436323),(0.5505955507861958,0.19145393798144705,1.8788156352163994),(-0.6092686217773406,0.812502961290914,1.685712743757831)])
+ m=MEDCoupling1SGTUMesh("mesh",NORM_PENTA6) ; m.setCoords(coo)
+ exp4=2.5041256256889888
+ self.assertAlmostEqual(exp4,coo.buildEuclidianDistanceDenseMatrix().getMaxValue()[0],12)# <- the definition of diameter
+ for delta in xrange(3):
+ c=[(elt+delta)%3 for elt in xrange(3)]
+ c+=[elt+3 for elt in c]
+ m.setNodalConnectivity(DataArrayInt(c))
+ self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp4,12)
+ m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
+ self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp4,12)
+ c.reverse()
+ m.setNodalConnectivity(DataArrayInt(c))
+ self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp4,12)
+ m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
+ self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp4,12)
+ # HEXA8
+ # noise of coo=DataArrayDouble([(0,0,0),(1,0,0),(1,1,0),(0,1,0),(0,0,2),(1,0,2),(1,1,2),(0,1,2)]) + rotation([0.7,-1.2,0.6],[-4,-1,10],0.3)
+ coo=DataArrayDouble([(-0.21266406388867243,-0.3049569460042527,-0.11012394815006032),(0.7641037943272584,-0.06990814759929553,-0.0909613877456491),(0.47406560768559974,0.8681310650341907,-0.2577311403703061),(-0.5136830410871793,0.644390554940524,-0.21319015989794698),(-0.4080167737381202,-0.12853761670628505,1.7869166291979348),(0.5650318811550441,0.20476257733110748,1.8140158890821603),(0.3230844436386215,1.1660778242678538,1.7175073141333406),(-0.6656588358432984,0.918357550969698,1.7566470691880265)])
+ m=MEDCoupling1SGTUMesh("mesh",NORM_HEXA8) ; m.setCoords(coo)
+ exp5=2.5366409441884215
+ self.assertAlmostEqual(exp5,coo.buildEuclidianDistanceDenseMatrix().getMaxValue()[0],12)# <- the definition of diameter
+ for delta in xrange(4):
+ c=[(elt+delta)%4 for elt in xrange(4)]
+ c+=[elt+4 for elt in c]
+ m.setNodalConnectivity(DataArrayInt(c))
+ self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp5,12)
+ m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
+ self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp5,12)
+ c.reverse()
+ m.setNodalConnectivity(DataArrayInt(c))
+ self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp5,12)
+ m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
+ self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp5,12)
+ # PYRA5 (1) 5th node is further
+ # noise of coo=DataArrayDouble([(0,0,0),(1,0,0),(1,1,0),(0,1,0),(0.5,0.5,2)]) + rotation([0.7,-1.2,0.6],[-4,-1,10],0.3)
+ coo=DataArrayDouble([(-0.31638393672228626,-0.3157865246451914,-0.12555467233075002),(0.7281379795666488,0.03836511217237115,-0.08431662762197323),(0.4757967840735147,0.8798897996143908,-0.2680890320119049),(-0.5386339871809047,0.5933159894201252,-0.2975311238319419),(0.012042592988768974,0.534282135495012,1.7859521682027926)])
+ m=MEDCoupling1SGTUMesh("mesh",NORM_PYRA5) ; m.setCoords(coo)
+ exp6=2.1558368027391386
+ self.assertAlmostEqual(exp6,coo.buildEuclidianDistanceDenseMatrix().getMaxValue()[0],12)# <- the definition of diameter
+ for delta in xrange(4):
+ c=[(elt+delta)%4 for elt in xrange(4)]
+ c+=[4]
+ m.setNodalConnectivity(DataArrayInt(c))
+ self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp6,12)
+ m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
+ self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp6,12)
+ pass
+ # PYRA5 (2) 5th node is closer
+ # noise of coo=DataArrayDouble([(0,0,0),(1,0,0),(1,1,0),(0,1,0),(0.5,0.5,0.1)]) + rotation([0.7,-1.2,0.6],[-4,-1,10],0.3)
+ coo=DataArrayDouble([(-0.31638393672228626,-0.3157865246451914,-0.12555467233075002),(0.7281379795666488,0.03836511217237115,-0.08431662762197323),(0.4757967840735147,0.8798897996143908,-0.2680890320119049),(-0.5386339871809047,0.5933159894201252,-0.2975311238319419),(0.092964408350795,0.33389670321297005,-0.10171764888060142)])
+ m=MEDCoupling1SGTUMesh("mesh",NORM_PYRA5) ; m.setCoords(coo)
+ exp7=1.4413563787228953
+ self.assertAlmostEqual(exp7,coo.buildEuclidianDistanceDenseMatrix().getMaxValue()[0],12)# <- the definition of diameter
+ for delta in xrange(4):
+ c=[(elt+delta)%4 for elt in xrange(4)]
+ c+=[4]
+ m.setNodalConnectivity(DataArrayInt(c))
+ self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp7,12)
+ m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
+ self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp7,12)
+ pass
+ # TETRA4
+ # noise of coo=DataArrayDouble([(0,0,0),(1,0,0),(0,1,0),(1,1,1)]) + rotation([0.7,-1.2,0.6],[-4,-1,10],0.3)
+ coo=DataArrayDouble([(-0.2256894071281369,-0.27631691290428106,-0.20266086543995965),(0.655458695100186,-0.08173323565551605,-0.19254662462061933),(-0.49893490718947264,0.5848097154568599,-0.3039928255382145),(0.2988102920828487,1.0582266398878504,0.7347375047372364)])
+ m=MEDCoupling1SGTUMesh("mesh",NORM_TETRA4) ; m.setCoords(coo)
+ exp8=1.7131322579364157
+ self.assertAlmostEqual(exp8,coo.buildEuclidianDistanceDenseMatrix().getMaxValue()[0],12)# <- the definition of diameter
+ for c in [[0,1,2,3],[0,3,2,1],[0,1,3,2],[0,2,3,1],[0,3,1,2],[0,2,1,3]]:
+ for i in xrange(4):
+ m.setNodalConnectivity(DataArrayInt([(elt+i)%4 for elt in c]))
+ self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp8,12)
+ m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
+ self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp8,12)
+ pass
+ pass
+ pass
+
+ def testMEDCouplingSkyLineArray(self):
+ index = DataArrayInt([ 0, 3, 5, 6, 6 ])
+ value = DataArrayInt([ 1, 2, 3, 2, 3, 3 ])
+
+ sla0 = MEDCouplingSkyLineArray()
+ self.assertEqual( -1, sla0.getNumberOf() )
+ self.assertEqual( 0, sla0.getLength() )
+ sla0.set( index, value )
+ self.assertTrue( index.isEqual( sla0.getIndexArray() ))
+ self.assertTrue( value.isEqual( sla0.getValueArray() ))
+ self.assertEqual( 4, sla0.getNumberOf() )
+ self.assertEqual( 6, sla0.getLength() )
+
+ sla1 = MEDCouplingSkyLineArray( index, value )
+ self.assertTrue( index.isEqual( sla1.getIndexArray() ))
+ self.assertTrue( value.isEqual( sla1.getValueArray() ))
+ self.assertEqual( 4, sla1.getNumberOf() )
+ self.assertEqual( 6, sla1.getLength() )
+
+ sla2 = MEDCouplingSkyLineArray( sla1 )
+ self.assertTrue( index.isEqual( sla2.getIndexArray() ))
+ self.assertTrue( value.isEqual( sla2.getValueArray() ))
+ self.assertEqual( 4, sla2.getNumberOf() )
+ self.assertEqual( 6, sla2.getLength() )
+
+ indexVec = ivec(); indexVec.reserve( len( index ))
+ for i in index: indexVec.push_back( i[0] )
+ valueVec = ivec(); valueVec.reserve( len( value ))
+ for i in value: valueVec.push_back( i[0] )
+ sla3 = MEDCouplingSkyLineArray( indexVec, valueVec )
+ self.assertTrue( index.isEqual( sla3.getIndexArray() ))
+ self.assertTrue( value.isEqual( sla3.getValueArray() ))
+ self.assertEqual( 4, sla3.getNumberOf() )
+ self.assertEqual( 6, sla3.getLength() )
+
+ pass
+
+ def testMEDCouplingUMeshgenerateGraph(self):
+ # cartesian mesh 3x3
+ arr=DataArrayDouble(4) ; arr.iota()
+ c=MEDCouplingCMesh() ; c.setCoords(arr,arr)
+ m=c.buildUnstructured()
+ graph = m.generateGraph()
+ # 0 1 2
+ # 3 4 5
+ # 6 7 8
+ valRef=[ 0,1,3,
+ 0,1,2,4,
+ 1,2,5,
+ 0,3,4,6,
+ 1,3,4,5,7,
+ 2,4,5,8,
+ 3,6,7,
+ 4,6,7,8,
+ 5,7,8]
+ self.assertEqual(valRef,list(graph.getValueArray().getValues()));
+
+ indRef=[0, 3, 7, 10, 14, 19, 23, 26, 30, 33]
+ self.assertEqual(indRef,list(graph.getIndexArray().getValues()));
+ pass
+
+ def testSwig2MEDCouplingCurveLinearReprQuick1(self):
+ """Non regression test. Error in m.__str__ when m is a MEDCouplingCurveLinear with spaceDim != meshDim."""
+ arr=DataArrayDouble(12) ; arr.iota() ; arr.rearrange(2)
+ m=MEDCouplingCurveLinearMesh()
+ m.setCoords(arr)
+ m.setNodeGridStructure([3,2])
+ m.checkCoherency()
+ self.assertEqual(m.getMeshDimension(),2)
+ self.assertEqual(m.getSpaceDimension(),2)
+ self.assertTrue(not "mismatch" in m.__str__())
+ self.assertTrue(not "mismatch" in m.__repr__())
+ #
+ arr=DataArrayDouble(18) ; arr.iota() ; arr.rearrange(3)
+ m.setCoords(arr)
+ self.assertEqual(m.getMeshDimension(),2)
+ self.assertEqual(m.getSpaceDimension(),3)
+ self.assertTrue(not "mismatch" in m.__str__())
+ self.assertTrue(not "mismatch" in m.__repr__())# bug was here !
pass
pass
