src/MEDCoupling/Test/MEDCouplingBasicsTest4.cxx

   1 // Copyright (C) 2007-2020  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // Author : Anthony Geay (CEA/DEN)
  20
  21 #include "MEDCouplingBasicsTest4.hxx"
  22 #include "MEDCouplingUMesh.hxx"
  23 #include "MEDCouplingCMesh.hxx"
  24 #include "MEDCouplingMappedExtrudedMesh.hxx"
  25 #include "MEDCouplingFieldDouble.hxx"
  26 #include "MEDCouplingMemArray.txx"
  27 #include "MEDCouplingGaussLocalization.hxx"
  28 #include "MEDCouplingMultiFields.hxx"
  29 #include "MEDCouplingFieldOverTime.hxx"
  30
  31 #include <cmath>
  32 #include <functional>
  33 #include <iterator>
  34
  35 using namespace MEDCoupling;
  36
  37 void MEDCouplingBasicsTest4::testDescriptionInMeshTimeUnit1()
  38 {
  39   static const char text1[]="totoTTEDD";
  40   MEDCouplingUMesh *m=build2DTargetMesh_1();
  41   m->setDescription(text1);
  42   CPPUNIT_ASSERT(std::string(m->getDescription())==text1);
  43   MEDCouplingUMesh *m2=(MEDCouplingUMesh *)m->deepCopy();
  44   CPPUNIT_ASSERT(m->isEqual(m2,1e-12));
  45   CPPUNIT_ASSERT(std::string(m2->getDescription())==text1);
  46   m2->setDescription("ggg");
  47   CPPUNIT_ASSERT(!m->isEqual(m2,1e-12));
  48   m2->decrRef();
  49   //
  50   MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
  51   f->setTimeUnit(text1);
  52   CPPUNIT_ASSERT(std::string(f->getTimeUnit())==text1);
  53   MEDCouplingFieldDouble *f2=f->deepCopy();
  54   CPPUNIT_ASSERT(std::string(f2->getTimeUnit())==text1);
  55   f2->decrRef();
  56   //
  57   f->decrRef();
  58   m->decrRef();
  59 }
  60
  61 void MEDCouplingBasicsTest4::testMultiFields1()
  62 {
  63   MEDCouplingMultiFields *mfs=buildMultiFields_1();
  64   std::vector<MEDCouplingMesh *> ms=mfs->getMeshes();
  65   std::vector<int> refs;
  66   std::vector<MEDCouplingMesh *> dms=mfs->getDifferentMeshes(refs);
  67   std::vector<DataArrayDouble *> das=mfs->getArrays();
  68   std::vector< std::vector<int> > refs2;
  69   std::vector<DataArrayDouble *> das2=mfs->getDifferentArrays(refs2);
  70   //
  71   CPPUNIT_ASSERT_EQUAL(5,(int)ms.size());
  72   CPPUNIT_ASSERT_EQUAL(2,(int)dms.size());
  73   CPPUNIT_ASSERT_EQUAL(6,(int)das.size());
  74   CPPUNIT_ASSERT_EQUAL(5,(int)das2.size());
  75   //
  76   MEDCouplingMultiFields *mfs2=mfs->deepCopy();
  77   CPPUNIT_ASSERT(mfs->isEqual(mfs2,1e-12,1e-12));
  78   mfs2->decrRef();
  79   //
  80   mfs->decrRef();
  81 }
  82
  83 void MEDCouplingBasicsTest4::testFieldOverTime1()
  84 {
  85   std::vector<MEDCouplingFieldDouble *> fs=buildMultiFields_2();
  86   CPPUNIT_ASSERT_THROW(MEDCouplingFieldOverTime::New(fs),INTERP_KERNEL::Exception);
  87   MEDCouplingFieldDouble *f4bis=fs[4]->buildNewTimeReprFromThis(ONE_TIME,false);
  88   fs[4]->decrRef();
  89   fs[4]=f4bis;
  90   CPPUNIT_ASSERT_THROW(MEDCouplingFieldOverTime::New(fs),INTERP_KERNEL::Exception);
  91   f4bis->setTime(2.7,20,21);
  92   MEDCouplingFieldOverTime *fot=MEDCouplingFieldOverTime::New(fs);
  93   MEDCouplingDefinitionTime dt=fot->getDefinitionTimeZone();
  94   std::vector<double> hs=dt.getHotSpotsTime();
  95   CPPUNIT_ASSERT_EQUAL(6,(int)hs.size());
  96   const double expected1[]={0.2,0.7,1.2,1.35,1.7,2.7};
  97   for(int i=0;i<6;i++)
  98     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],hs[i],1e-12);
  99   int meshId,arrId,arrIdInField,fieldId;
 100   dt.getIdsOnTimeRight(0.2,meshId,arrId,arrIdInField,fieldId);
 101   CPPUNIT_ASSERT_EQUAL(0,meshId);
 102   CPPUNIT_ASSERT_EQUAL(0,arrId);
 103   CPPUNIT_ASSERT_EQUAL(0,arrIdInField);
 104   CPPUNIT_ASSERT_EQUAL(0,fieldId);
 105   //
 106   dt.getIdsOnTimeRight(0.7,meshId,arrId,arrIdInField,fieldId);
 107   CPPUNIT_ASSERT_EQUAL(0,meshId);
 108   CPPUNIT_ASSERT_EQUAL(1,arrId);
 109   CPPUNIT_ASSERT_EQUAL(0,arrIdInField);
 110   CPPUNIT_ASSERT_EQUAL(1,fieldId);
 111   //
 112   dt.getIdsOnTimeLeft(1.2,meshId,arrId,arrIdInField,fieldId);//**** WARNING left here
 113   CPPUNIT_ASSERT_EQUAL(0,meshId);
 114   CPPUNIT_ASSERT_EQUAL(2,arrId);
 115   CPPUNIT_ASSERT_EQUAL(1,arrIdInField);
 116   CPPUNIT_ASSERT_EQUAL(1,fieldId);
 117   //
 118   dt.getIdsOnTimeRight(1.2,meshId,arrId,arrIdInField,fieldId);//**** WARNING right again here
 119   CPPUNIT_ASSERT_EQUAL(1,meshId);
 120   CPPUNIT_ASSERT_EQUAL(3,arrId);
 121   CPPUNIT_ASSERT_EQUAL(0,arrIdInField);
 122   CPPUNIT_ASSERT_EQUAL(2,fieldId);
 123   //
 124   dt.getIdsOnTimeRight(1.35,meshId,arrId,arrIdInField,fieldId);
 125   CPPUNIT_ASSERT_EQUAL(1,meshId);
 126   CPPUNIT_ASSERT_EQUAL(3,arrId);
 127   CPPUNIT_ASSERT_EQUAL(0,arrIdInField);
 128   CPPUNIT_ASSERT_EQUAL(2,fieldId);
 129   //
 130   dt.getIdsOnTimeRight(1.7,meshId,arrId,arrIdInField,fieldId);
 131   CPPUNIT_ASSERT_EQUAL(0,meshId);
 132   CPPUNIT_ASSERT_EQUAL(3,arrId);
 133   CPPUNIT_ASSERT_EQUAL(0,arrIdInField);
 134   CPPUNIT_ASSERT_EQUAL(3,fieldId);
 135   //
 136   dt.getIdsOnTimeRight(2.7,meshId,arrId,arrIdInField,fieldId);
 137   CPPUNIT_ASSERT_EQUAL(1,meshId);
 138   CPPUNIT_ASSERT_EQUAL(4,arrId);
 139   CPPUNIT_ASSERT_EQUAL(0,arrIdInField);
 140   CPPUNIT_ASSERT_EQUAL(4,fieldId);
 141   //
 142   MEDCouplingDefinitionTime dt2;
 143   CPPUNIT_ASSERT(!dt2.isEqual(dt));
 144   dt2.assign(dt);
 145   dt2.assign(dt);//to check memory management
 146   CPPUNIT_ASSERT(dt2.isEqual(dt));
 147   //
 148   MEDCouplingDefinitionTime dt3;
 149   std::vector<int> tmp1;
 150   std::vector<double> tmp2;
 151   CPPUNIT_ASSERT(!dt2.isEqual(dt3));
 152   dt2.getTinySerializationInformation(tmp1,tmp2);
 153   dt3.unserialize(tmp1,tmp2);
 154   CPPUNIT_ASSERT(dt2.isEqual(dt3));
 155   //
 156   for(std::vector<MEDCouplingFieldDouble *>::iterator it=fs.begin();it!=fs.end();it++)
 157     (*it)->decrRef();
 158   fot->decrRef();
 159 }
 160
 161 void MEDCouplingBasicsTest4::testDAICheckAndPreparePermutation1()
 162 {
 163   const mcIdType vals1[]={9,10,0,6,4,11,3,7};
 164   const mcIdType expect1[]={5,6,0,3,2,7,1,4};
 165   const mcIdType vals2[]={9,10,0,6,10,11,3,7};
 166   DataArrayIdType *da=DataArrayIdType::New();
 167   da->alloc(8,1);
 168   std::copy(vals1,vals1+8,da->getPointer());
 169   DataArrayIdType *da2=da->checkAndPreparePermutation();
 170   CPPUNIT_ASSERT_EQUAL(8,(int)da2->getNumberOfTuples());
 171   CPPUNIT_ASSERT_EQUAL(1,(int)da2->getNumberOfComponents());
 172   for(int i=0;i<8;i++)
 173     CPPUNIT_ASSERT_EQUAL(expect1[i],da2->getIJ(i,0));
 174   da2->decrRef();
 175   da->decrRef();
 176   //
 177   da=DataArrayIdType::New();
 178   da->alloc(8,1);
 179   da->iota(0);
 180   da2=da->checkAndPreparePermutation();
 181   CPPUNIT_ASSERT_EQUAL(1,(int)da2->getNumberOfComponents());
 182   CPPUNIT_ASSERT(da2->isIota(8));
 183   da2->decrRef();
 184   da->decrRef();
 185   //
 186   da=DataArrayIdType::New();
 187   da->alloc(8,1);
 188   std::copy(vals2,vals2+8,da->getPointer());
 189   CPPUNIT_ASSERT_THROW(da->checkAndPreparePermutation(),INTERP_KERNEL::Exception);
 190   da->decrRef();
 191 }
 192
 193 void MEDCouplingBasicsTest4::testDAIChangeSurjectiveFormat1()
 194 {
 195   const mcIdType vals1[8]={0,3,2,3,2,2,1,2};
 196   const mcIdType expected1[5]={0,1,2,6,8};
 197   const mcIdType expected2[8]={0,  6,  2,4,5,7,  1,3};
 198   DataArrayIdType *da=DataArrayIdType::New();
 199   da->alloc(8,1);
 200   std::copy(vals1,vals1+8,da->getPointer());
 201   //
 202   DataArrayIdType *da2,*da2I;
 203   da->changeSurjectiveFormat(4,da2,da2I);
 204  CPPUNIT_ASSERT_EQUAL(5,(int)da2I->getNumberOfTuples());
 205  CPPUNIT_ASSERT_EQUAL(8,(int)da2->getNumberOfTuples());
 206   CPPUNIT_ASSERT(std::equal(expected1,expected1+5,da2I->getConstPointer()));
 207   CPPUNIT_ASSERT(std::equal(expected2,expected2+8,da2->getConstPointer()));
 208   da2->decrRef();
 209   da2I->decrRef();
 210   //
 211   CPPUNIT_ASSERT_THROW(da->changeSurjectiveFormat(3,da2,da2I),INTERP_KERNEL::Exception);
 212   //
 213   da->decrRef();
 214 }
 215
 216 void MEDCouplingBasicsTest4::testUMeshGetCellIdsLyingOnNodes1()
 217 {
 218   MEDCouplingUMesh *m=build3DSurfTargetMesh_1();
 219   const mcIdType nodeIds1[5]={1,2,3,4,6};
 220   const mcIdType nodeIds2[2]={6,7};
 221   DataArrayIdType *da=m->getCellIdsLyingOnNodes(nodeIds1,nodeIds1+5,true);
 222   CPPUNIT_ASSERT_EQUAL(1,(int)da->getNumberOfTuples());
 223   CPPUNIT_ASSERT_EQUAL(1,(int)da->getNumberOfComponents());
 224   CPPUNIT_ASSERT_EQUAL(1,(int)da->getIJ(0,0));
 225   da->decrRef();
 226   da=m->getCellIdsLyingOnNodes(nodeIds2,nodeIds2+2,false);
 227   CPPUNIT_ASSERT_EQUAL(2,(int)da->getNumberOfTuples());
 228   CPPUNIT_ASSERT_EQUAL(1,(int)da->getNumberOfComponents());
 229   CPPUNIT_ASSERT_EQUAL(3,(int)da->getIJ(0,0));
 230   CPPUNIT_ASSERT_EQUAL(4,(int)da->getIJ(1,0));
 231   da->decrRef();
 232   //
 233   m->decrRef();
 234 }
 235
 236 void MEDCouplingBasicsTest4::testUMeshFindCellIdsOnBoundary1()
 237 {
 238   MEDCouplingUMesh *m=build3DSurfTargetMesh_1();
 239   DataArrayIdType *da5=m->findCellIdsOnBoundary();
 240   CPPUNIT_ASSERT(da5->isIota(5));
 241   //
 242   da5->decrRef();
 243   m->decrRef();
 244 }
 245
 246 void MEDCouplingBasicsTest4::testMeshSetTime1()
 247 {
 248   MEDCouplingUMesh *m1=build3DSurfTargetMesh_1();
 249   MEDCouplingUMesh *m2=build3DSurfTargetMesh_1();
 250   //
 251   CPPUNIT_ASSERT(m1->isEqual(m2,1e-12));
 252   m1->setTime(3.14,6,7);
 253   int tmp1,tmp2;
 254   double tmp3=m1->getTime(tmp1,tmp2);
 255   CPPUNIT_ASSERT_EQUAL(6,tmp1);
 256   CPPUNIT_ASSERT_EQUAL(7,tmp2);
 257   CPPUNIT_ASSERT_DOUBLES_EQUAL(3.14,tmp3,1e-12);
 258   CPPUNIT_ASSERT(!m1->isEqual(m2,1e-12));
 259   m2->setTime(3.14,6,7);
 260   CPPUNIT_ASSERT(m1->isEqual(m2,1e-12));
 261   m1->setTimeUnit("ms");
 262   CPPUNIT_ASSERT(std::string(m1->getTimeUnit())=="ms");
 263   m1->setTimeUnit("us");
 264   CPPUNIT_ASSERT(std::string(m1->getTimeUnit())=="us");
 265   CPPUNIT_ASSERT(!m1->isEqual(m2,1e-12));
 266   m2->setTimeUnit("us");
 267   CPPUNIT_ASSERT(m1->isEqual(m2,1e-12));
 268   m2->setTime(3.14,6,8);
 269   CPPUNIT_ASSERT(!m1->isEqual(m2,1e-12));
 270   m2->setTime(3.14,7,7);
 271   CPPUNIT_ASSERT(!m1->isEqual(m2,1e-12));
 272   m2->setTime(3.15,6,7);
 273   CPPUNIT_ASSERT(!m1->isEqual(m2,1e-12));
 274   //
 275   m1->setTime(10.34,55,12);
 276   MEDCouplingUMesh *m3=(MEDCouplingUMesh *)m1->deepCopy();
 277   CPPUNIT_ASSERT(m1->isEqual(m3,1e-12));
 278   tmp3=m3->getTime(tmp1,tmp2);
 279   CPPUNIT_ASSERT_EQUAL(55,tmp1);
 280   CPPUNIT_ASSERT_EQUAL(12,tmp2);
 281   CPPUNIT_ASSERT_DOUBLES_EQUAL(10.34,tmp3,1e-12);
 282   //
 283   m3->decrRef();
 284   m1->decrRef();
 285   m2->decrRef();
 286   // testing CMesh
 287   const double coo1[4]={0.,1.,2.,3.5};
 288   DataArrayDouble *a=DataArrayDouble::New();
 289   a->alloc(4,1);
 290   std::copy(coo1,coo1+4,a->getPointer());
 291   MEDCouplingCMesh *b=MEDCouplingCMesh::New();
 292   b->setCoordsAt(0,a);
 293   a->decrRef();
 294   //
 295   b->setTime(5.67,8,100);
 296   tmp3=b->getTime(tmp1,tmp2);
 297   CPPUNIT_ASSERT_EQUAL(8,tmp1);
 298   CPPUNIT_ASSERT_EQUAL(100,tmp2);
 299   CPPUNIT_ASSERT_DOUBLES_EQUAL(5.67,tmp3,1e-12);
 300   MEDCouplingCMesh *c=(MEDCouplingCMesh *)b->deepCopy();
 301   CPPUNIT_ASSERT(c->isEqual(b,1e-12));
 302   tmp3=c->getTime(tmp1,tmp2);
 303   CPPUNIT_ASSERT_EQUAL(8,tmp1);
 304   CPPUNIT_ASSERT_EQUAL(100,tmp2);
 305   CPPUNIT_ASSERT_DOUBLES_EQUAL(5.67,tmp3,1e-12);
 306   c->decrRef();
 307   b->decrRef();
 308 }
 309
 310 void MEDCouplingBasicsTest4::testApplyFuncTwo1()
 311 {
 312   MEDCouplingUMesh *m1=build3DSurfTargetMesh_1();
 313   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
 314   f1->setMesh(m1);
 315   //
 316   const double vals[15]={1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.};
 317   DataArrayDouble *da=DataArrayDouble::New();
 318   da->alloc(5,3);
 319   std::copy(vals,vals+15,da->getPointer());
 320   f1->setArray(da);
 321   //
 322   CPPUNIT_ASSERT_THROW(da->applyFuncCompo(1,"y+z"),INTERP_KERNEL::Exception);
 323   da->setInfoOnComponent(0,"x [m]");
 324   da->setInfoOnComponent(1,"y [mm]");
 325   da->setInfoOnComponent(2,"z [km]");
 326
 327   CPPUNIT_ASSERT_THROW(da->applyFuncCompo(1,"x+y+zz+zzz"),INTERP_KERNEL::Exception);
 328   CPPUNIT_ASSERT_THROW(da->applyFuncCompo(1,"toto(x+y)"),INTERP_KERNEL::Exception);
 329   CPPUNIT_ASSERT_THROW(da->applyFuncCompo(1,"x/0"),INTERP_KERNEL::Exception);
 330
 331   DataArrayDouble *da2=da->applyFuncCompo(1,"y+z");
 332  CPPUNIT_ASSERT_EQUAL(1,(int)da2->getNumberOfComponents());
 333  CPPUNIT_ASSERT_EQUAL(5,(int)da2->getNumberOfTuples());
 334   const double expected1[5]={32.,34.,36.,38.,40.};
 335   for(int i=0;i<5;i++)
 336     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],da2->getIJ(0,i),1e-12);
 337   da2->decrRef();
 338   da2=da->applyFunc(1,"y+z");
 339   const double expected2[5]={12.,14.,16.,18.,20.};
 340   for(int i=0;i<5;i++)
 341     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],da2->getIJ(0,i),1e-12);
 342   da2->decrRef();
 343   //
 344  CPPUNIT_ASSERT_EQUAL(3,(int)f1->getNumberOfComponents());
 345  CPPUNIT_ASSERT_EQUAL(5,(int)f1->getNumberOfTuples());
 346   f1->applyFuncCompo(1,"y+z");
 347  CPPUNIT_ASSERT_EQUAL(1,(int)f1->getNumberOfComponents());
 348  CPPUNIT_ASSERT_EQUAL(5,(int)f1->getNumberOfTuples());
 349   for(int i=0;i<5;i++)
 350     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f1->getArray()->getIJ(0,i),1e-12);
 351   //
 352   da->decrRef();
 353   f1->decrRef();
 354   m1->decrRef();
 355 }
 356
 357 void MEDCouplingBasicsTest4::testApplyFuncThree1()
 358 {
 359   MEDCouplingUMesh *m1=build3DSurfTargetMesh_1();
 360   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
 361   f1->setMesh(m1);
 362   //
 363   const double vals[15]={1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.};
 364   DataArrayDouble *da=DataArrayDouble::New();
 365   da->alloc(5,3);
 366   std::copy(vals,vals+15,da->getPointer());
 367   f1->setArray(da);
 368   //
 369   std::vector<std::string> vs(3);
 370   vs[0]="x"; vs[1]="Y"; vs[2]="z";
 371   CPPUNIT_ASSERT_THROW(da->applyFuncNamedCompo(1,vs,"y+z"),INTERP_KERNEL::Exception);
 372   CPPUNIT_ASSERT_THROW(da->applyFuncNamedCompo(1,vs,"x+Y+z+zz+zzz"),INTERP_KERNEL::Exception);
 373   CPPUNIT_ASSERT_THROW(da->applyFuncNamedCompo(1,vs,"x/0."),INTERP_KERNEL::Exception);
 374   vs[1]="y";
 375   DataArrayDouble *da2=da->applyFuncNamedCompo(1,vs,"y+z");
 376   const double expected1[5]={32.,34.,36.,38.,40.};
 377   for(int i=0;i<5;i++)
 378     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],da2->getIJ(0,i),1e-12);
 379   da2->decrRef();
 380   std::vector<std::string> vs2(4); vs2[0]="x"; vs2[1]="y"; vs2[2]="z"; vs2[3]="a";
 381   CPPUNIT_ASSERT_THROW(da->applyFuncNamedCompo(1,vs2,"x+a"),INTERP_KERNEL::Exception);
 382   f1->setArray(da);
 383  CPPUNIT_ASSERT_EQUAL(3,(int)f1->getNumberOfComponents());
 384  CPPUNIT_ASSERT_EQUAL(5,(int)f1->getNumberOfTuples());
 385   f1->applyFuncNamedCompo(1,vs,"y+z");
 386  CPPUNIT_ASSERT_EQUAL(1,(int)f1->getNumberOfComponents());
 387  CPPUNIT_ASSERT_EQUAL(5,(int)f1->getNumberOfTuples());
 388   for(int i=0;i<5;i++)
 389     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f1->getArray()->getIJ(0,i),1e-12);
 390   //
 391   da->decrRef();
 392   f1->decrRef();
 393   m1->decrRef();
 394 }
 395
 396 void MEDCouplingBasicsTest4::testFillFromAnalyticTwo1()
 397 {
 398   MEDCouplingUMesh *m1=build3DSurfTargetMesh_1();
 399   m1->setTime(3.4,5,6); m1->setTimeUnit("us");
 400   int a,b;
 401   CPPUNIT_ASSERT_THROW(m1->fillFromAnalyticCompo(ON_NODES,1,"y+z"),INTERP_KERNEL::Exception);
 402   m1->getCoords()->setInfoOnComponent(0,"x [m]");
 403   m1->getCoords()->setInfoOnComponent(1,"y");
 404   m1->getCoords()->setInfoOnComponent(2,"z");
 405   MEDCouplingFieldDouble *f1=m1->fillFromAnalyticCompo(ON_NODES,1,"y+z");
 406   CPPUNIT_ASSERT_DOUBLES_EQUAL(3.4,f1->getTime(a,b),1.e-14);
 407   CPPUNIT_ASSERT_EQUAL(5,a); CPPUNIT_ASSERT_EQUAL(6,b);
 408   CPPUNIT_ASSERT_EQUAL(std::string(f1->getTimeUnit()),std::string("us"));
 409   CPPUNIT_ASSERT_EQUAL(1,(int)f1->getNumberOfComponents());
 410   CPPUNIT_ASSERT_EQUAL(9,(int)f1->getNumberOfTuples());
 411   const double expected1[9]={0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2};
 412   for(int i=0;i<9;i++)
 413     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f1->getArray()->getIJ(0,i),1e-12);
 414   f1->decrRef();
 415   m1->decrRef();
 416 }
 417
 418 void MEDCouplingBasicsTest4::testFillFromAnalyticThree1()
 419 {
 420   MEDCouplingUMesh *m1=build3DSurfTargetMesh_1();
 421   m1->setTime(3.4,5,6); m1->setTimeUnit("us");
 422   int a,b;
 423   std::vector<std::string> vs(3);
 424   vs[0]="x"; vs[1]="Y"; vs[2]="z";
 425   CPPUNIT_ASSERT_THROW(m1->fillFromAnalyticNamedCompo(ON_NODES,1,vs,"y+z"),INTERP_KERNEL::Exception);
 426   vs[1]="y";
 427   MEDCouplingFieldDouble *f1=m1->fillFromAnalyticNamedCompo(ON_NODES,1,vs,"y+z");
 428   CPPUNIT_ASSERT_DOUBLES_EQUAL(3.4,f1->getTime(a,b),1.e-14);
 429   CPPUNIT_ASSERT_EQUAL(5,a); CPPUNIT_ASSERT_EQUAL(6,b);
 430   CPPUNIT_ASSERT_EQUAL(std::string(f1->getTimeUnit()),std::string("us"));
 431  CPPUNIT_ASSERT_EQUAL(1,(int)f1->getNumberOfComponents());
 432  CPPUNIT_ASSERT_EQUAL(9,(int)f1->getNumberOfTuples());
 433   const double expected1[9]={0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2};
 434   for(int i=0;i<9;i++)
 435     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f1->getArray()->getIJ(0,i),1e-12);
 436   f1->decrRef();
 437   m1->decrRef();
 438 }
 439
 440 void MEDCouplingBasicsTest4::testDAUnitVar1()
 441 {
 442   DataArrayDouble *da=DataArrayDouble::New();
 443   da->alloc(1,3);
 444   da->setInfoOnComponent(0,"XPS [m]");
 445   std::string st1,st2;
 446   st1=da->getVarOnComponent(0);
 447   CPPUNIT_ASSERT(st1=="XPS");
 448   st2=da->getUnitOnComponent(0);
 449   CPPUNIT_ASSERT(st2=="m");
 450   //
 451   da->setInfoOnComponent(0,"XPS         [m]");
 452   st1=da->getVarOnComponent(0);
 453   CPPUNIT_ASSERT(st1=="XPS");
 454   st2=da->getUnitOnComponent(0);
 455   CPPUNIT_ASSERT(st2=="m");
 456   //
 457   da->setInfoOnComponent(0,"XPP         [m]");
 458   st1=da->getVarOnComponent(0);
 459   CPPUNIT_ASSERT(st1=="XPP");
 460   st2=da->getUnitOnComponent(0);
 461   CPPUNIT_ASSERT(st2=="m");
 462   //
 463   da->setInfoOnComponent(0,"XPP kdep  kefer   [ m  ]");
 464   st1=da->getVarOnComponent(0);
 465   CPPUNIT_ASSERT(st1=="XPP kdep  kefer");
 466   st2=da->getUnitOnComponent(0);
 467   CPPUNIT_ASSERT(st2==" m  ");
 468   //
 469   da->setInfoOnComponent(0,"     XPP k[  dep  k]efer   [ m^ 2/s^3*kJ  ]");
 470   st1=da->getVarOnComponent(0);
 471   CPPUNIT_ASSERT(st1=="     XPP k[  dep  k]efer");
 472   st2=da->getUnitOnComponent(0);
 473   CPPUNIT_ASSERT(st2==" m^ 2/s^3*kJ  ");
 474   //
 475   da->setInfoOnComponent(0,"     XPP kefer   ");
 476   st1=da->getVarOnComponent(0);
 477   CPPUNIT_ASSERT(st1=="     XPP kefer   ");
 478   st2=da->getUnitOnComponent(0);
 479   CPPUNIT_ASSERT(st2=="");
 480   //
 481   da->setInfoOnComponent(0,"temperature( bof)");
 482   st1=da->getVarOnComponent(0);
 483   CPPUNIT_ASSERT(st1=="temperature( bof)");
 484   st2=da->getUnitOnComponent(0);
 485   CPPUNIT_ASSERT(st2=="");
 486   //
 487   da->setInfoOnComponent(0,"kkk [m]");
 488   da->setInfoOnComponent(1,"ppp   [m^2/kJ]");
 489   da->setInfoOnComponent(2,"abcde   [MW/s]");
 490   //
 491   std::vector<std::string> vs;
 492   vs=da->getVarsOnComponent();
 493   CPPUNIT_ASSERT_EQUAL(3,(int)vs.size());
 494   CPPUNIT_ASSERT(vs[0]=="kkk");
 495   CPPUNIT_ASSERT(vs[1]=="ppp");
 496   CPPUNIT_ASSERT(vs[2]=="abcde");
 497   vs=da->getUnitsOnComponent();
 498   CPPUNIT_ASSERT_EQUAL(3,(int)vs.size());
 499   CPPUNIT_ASSERT(vs[0]=="m");
 500   CPPUNIT_ASSERT(vs[1]=="m^2/kJ");
 501   CPPUNIT_ASSERT(vs[2]=="MW/s");
 502   //
 503   da->decrRef();
 504 }
 505
 506 void MEDCouplingBasicsTest4::testGaussCoordinates1()
 507 {
 508   //Testing 1D cell types
 509   MEDCouplingUMesh *m1=build1DMultiTypes_1();
 510   MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_GAUSS_PT,ONE_TIME);
 511   f->setMesh(m1);
 512   std::vector<double> wg1(1); wg1[0]=0.3;
 513   std::vector<double> gsCoo1(1); gsCoo1[0]=0.2;
 514   std::vector<double> refCoo1(2); refCoo1[0]=-1.0; refCoo1[1]=1.0;
 515   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_SEG2,refCoo1,gsCoo1,wg1);
 516   std::vector<double> wg2(wg1);
 517   std::vector<double> gsCoo2(1); gsCoo2[0]=0.2;
 518   std::vector<double> refCoo2(3); refCoo2[0]=-1.0; refCoo2[1]=1.0; refCoo2[2]=0.0;
 519   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_SEG3,refCoo2,gsCoo2,wg2);
 520   //
 521   DataArrayDouble *resToTest=f->getLocalizationOfDiscr();
 522  CPPUNIT_ASSERT_EQUAL(3,(int)resToTest->getNumberOfComponents());
 523  CPPUNIT_ASSERT_EQUAL(2,(int)resToTest->getNumberOfTuples());
 524   const double expected1[6]={0.6,0.6,0.6, 0.6,0.6,0.6};
 525   for(int i=0;i<6;i++)
 526     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],resToTest->getIJ(0,i),1e-14);
 527   resToTest->decrRef();
 528   //
 529   m1->decrRef();
 530   f->decrRef();
 531   //Testing 2D cell types
 532   MEDCouplingUMesh *m2=build2DMultiTypes_1();
 533   f=MEDCouplingFieldDouble::New(ON_GAUSS_PT,ONE_TIME);
 534   f->setMesh(m2);
 535   std::vector<double> wg3(2); wg3[0]=0.3; wg3[1]=0.3;
 536   const double tria3CooGauss[4]={ 0.1, 0.8, 0.2, 0.7 };
 537   std::vector<double> gsCoo3(tria3CooGauss,tria3CooGauss+4);
 538   const double tria3CooRef[6]={ 0.0, 0.0, 1.0 , 0.0, 0.0, 1.0 };
 539   std::vector<double> refCoo3(tria3CooRef,tria3CooRef+6);
 540   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TRI3,refCoo3,gsCoo3,wg3);
 541   std::vector<double> wg4(3); wg4[0]=0.3; wg4[1]=0.3; wg4[2]=0.3;
 542   const double tria6CooGauss[6]={ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4 };
 543   std::vector<double> gsCoo4(tria6CooGauss,tria6CooGauss+6);
 544   const double tria6CooRef[12]={0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.5, 0.0, 0.5, 0.5, 0.0, 0.5};
 545   std::vector<double> refCoo4(tria6CooRef,tria6CooRef+12);
 546   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TRI6,refCoo4,gsCoo4,wg4);
 547   std::vector<double> wg5(4); wg5[0]=0.3; wg5[1]=0.3; wg5[2]=0.3; wg5[3]=0.3;
 548   const double quad4CooGauss[8]={ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4, 0.15, 0.27 };
 549   std::vector<double> gsCoo5(quad4CooGauss,quad4CooGauss+8);
 550   const double quad4CooRef[8]={-1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0};
 551   std::vector<double> refCoo5(quad4CooRef,quad4CooRef+8);
 552   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_QUAD4,refCoo5,gsCoo5,wg5);
 553   std::vector<double> wg6(4); wg6[0]=0.3; wg6[1]=0.3; wg6[2]=0.3; wg6[3]=0.3;
 554   const double quad8CooGauss[8]={ 0.34, 0.16, 0.21, 0.3, 0.23, 0.4, 0.14, 0.37 };
 555   std::vector<double> gsCoo6(quad8CooGauss,quad8CooGauss+8);
 556   const double quad8CooRef[16]={ -1.0, -1.0, 1.0, -1.0, 1.0,  1.0, -1.0,  1.0, 0.0, -1.0, 1.0,  0.0, 0.0,  1.0, -1.0,  0.0};
 557   std::vector<double> refCoo6(quad8CooRef,quad8CooRef+16);
 558   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_QUAD8,refCoo6,gsCoo6,wg6);
 559   //
 560   resToTest=f->getLocalizationOfDiscr();
 561   CPPUNIT_ASSERT_EQUAL(3,(int)resToTest->getNumberOfComponents());
 562   CPPUNIT_ASSERT_EQUAL(13,(int)resToTest->getNumberOfTuples());//2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
 563   const double expected2[39]={5.1,1.55,0.0, 4.7,1.65,0.0, //TRI3
 564                               2.32,1.52,0.0, 1.6,1.32,0.0, 3.52,1.26,0.0,//TRI6
 565                               2.6,1.6,0.0, 2.4,1.8,0.0, 2.4,1.2,0.0, 2.3,1.46,0.0,//QUAD4
 566                               2.32,2.68,0.0, 2.6,2.42,0.0, 2.8,2.46,0.0, 2.74,2.28,0.0 };//QUAD8
 567   for(int i=0;i<39;i++)
 568     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],resToTest->getIJ(0,i),1e-14);
 569   resToTest->decrRef();
 570   //
 571   m2->decrRef();
 572   f->decrRef();
 573   //Testing 3D cell types
 574   MEDCouplingUMesh *m3=build3DMultiTypes_1();
 575   f=MEDCouplingFieldDouble::New(ON_GAUSS_PT,ONE_TIME);
 576   f->setMesh(m3);
 577   //
 578   std::vector<double> wg7(1); wg7[0]=0.3;
 579   const double tetra4CooGauss[3]={0.34, 0.16, 0.21};
 580   std::vector<double> gsCoo7(tetra4CooGauss,tetra4CooGauss+3);
 581   const double tetra4CooRef[12]={0.0,1.0,0.0, 0.0,0.0,1.0, 0.0,0.0,0.0, 1.0,0.0,0.0};
 582   std::vector<double> refCoo7(tetra4CooRef,tetra4CooRef+12);
 583   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TETRA4,refCoo7,gsCoo7,wg7);
 584   std::vector<double> wg8(1); wg8[0]=0.3;
 585   const double tetra10CooGauss[3]={0.2, 0.3, 0.1};
 586   std::vector<double> gsCoo8(tetra10CooGauss,tetra10CooGauss+3);
 587   const double tetra10CooRef[30]={0.0,1.0,0.0, 0.0,0.0,0.0, 0.0,0.0,1.0, 1.0,0.0,0.0, 0.0,0.5,0.0, 0.0,0.0,0.5, 0.0,0.5,0.5, 0.5,0.5,0.0, 0.5,0.0,0.0, 0.5,0.0,0.5};
 588   std::vector<double> refCoo8(tetra10CooRef,tetra10CooRef+30);
 589   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TETRA10,refCoo8,gsCoo8,wg8);
 590   std::vector<double> wg9(1); wg9[0]=0.3;
 591   const double pyra5CooGauss[3]={0.2, 0.3, 0.1};
 592   std::vector<double> gsCoo9(pyra5CooGauss,pyra5CooGauss+3);
 593   const double pyra5CooRef[15]={1.0,0.0,0.0, 0.0,1.0,0.0, -1.0,0.0,0.0, 0.0,-1.0,0.0, 0.0,0.0,1.0};
 594   std::vector<double> refCoo9(pyra5CooRef,pyra5CooRef+15);
 595   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_PYRA5,refCoo9,gsCoo9,wg9);
 596   std::vector<double> wg10(1); wg10[0]=0.3;
 597   const double pyra13CooGauss[3]={0.1, 0.2, 0.7};
 598   std::vector<double> gsCoo10(pyra13CooGauss,pyra13CooGauss+3);
 599   const double pyra13CooRef[39]={1.0,0.0,0.0, 0.0,1.0,0.0,-1.0,0.0,0.0,0.0,-1.0,0.0,0.0,0.0,1.0,0.5,0.5,0.0,-0.5,0.5,0.0,-0.5,-0.5,0.0,0.5,-0.5,0.0,0.5,0.0,0.5,0.0,0.5,0.5,-0.5,0.0,0.5,0.0,-0.5,0.5};
 600   std::vector<double> refCoo10(pyra13CooRef,pyra13CooRef+39);
 601   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_PYRA13,refCoo10,gsCoo10,wg10);
 602   std::vector<double> wg11(1); wg11[0]=0.3;
 603   const double penta6CooGauss[3]={0.2, 0.3, 0.1};
 604   std::vector<double> gsCoo11(penta6CooGauss,penta6CooGauss+3);
 605   const double penta6CooRef[18]={-1.0,1.0,0.0,-1.0,-0.0,1.0,-1.0,0.0,0.0,1.0,1.0,0.0,1.0,0.0,1.0,1.0,0.0,0.0};
 606   std::vector<double> refCoo11(penta6CooRef,penta6CooRef+18);
 607   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_PENTA6,refCoo11,gsCoo11,wg11);
 608   std::vector<double> wg12(1); wg12[0]=0.3;
 609   const double penta15CooGauss[3]={0.2, 0.3,0.15};
 610   std::vector<double> gsCoo12(penta15CooGauss,penta15CooGauss+3);
 611   const double penta15CooRef[45]={-1.0,1.0,0.0,-1.0,0.0,1.0,-1.0,0.0,0.0,1.0,1.0,0.0,1.0,0.0,1.0,1.0,0.0,0.0,-1.0,0.5,0.5,-1.0,0.0,0.5,-1.0,0.5,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.5,0.5,1.0,0.0, 0.5,1.0,0.5,0.0};
 612   std::vector<double> refCoo12(penta15CooRef,penta15CooRef+45);
 613   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_PENTA15,refCoo12,gsCoo12,wg12);
 614   std::vector<double> wg13(1); wg13[0]=0.3;
 615   const double hexa8CooGauss[3]={0.2,0.3,0.15};
 616   std::vector<double> gsCoo13(hexa8CooGauss,hexa8CooGauss+3);
 617   const double hexa8CooRef[24]={-1.0,-1.0,-1.0,1.0,-1.0,-1.0,1.0,1.0,-1.0,-1.0,1.0,-1.0,-1.0,-1.0,1.0,1.0,-1.0,1.0,1.0,1.0,1.0,-1.0,1.0,1.0};
 618   std::vector<double> refCoo13(hexa8CooRef,hexa8CooRef+24);
 619   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_HEXA8,refCoo13,gsCoo13,wg13);
 620   std::vector<double> wg14(1); wg14[0]=0.3;
 621   const double hexa20CooGauss[3]={0.11,0.3,0.55};
 622   std::vector<double> gsCoo14(hexa20CooGauss,hexa20CooGauss+3);
 623   const double hexa20CooRef[60]={-1.0,-1.0,-1.0,1.0,-1.0,-1.0,1.0,1.0,-1.0,-1.0,1.0,-1.0,-1.0,-1.0,1.0,1.0,-1.0,1.0,1.0,1.0,1.0,-1.0,1.0,1.0,0.0,-1.0,-1.0,1.0,0.0,-1.0,0.0,1.0,-1.0,-1.0,0.0,-1.0,-1.0,-1.0,0.0,1.0,-1.0,0.0,1.0,1.0,0.0,-1.0,1.0,0.0,0.0,-1.0,1.0,1.0,0.0,1.0,0.0,1.0,1.0,-1.0,0.0,1.0};
 624   std::vector<double> refCoo14(hexa20CooRef,hexa20CooRef+60);
 625   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_HEXA20,refCoo14,gsCoo14,wg14);
 626   //
 627   resToTest=f->getLocalizationOfDiscr();
 628   CPPUNIT_ASSERT_EQUAL(3,(int)resToTest->getNumberOfComponents());
 629   CPPUNIT_ASSERT_EQUAL(8,(int)resToTest->getNumberOfTuples());//2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
 630   const double expected3[24]={1.312,3.15,1.02, 0.56,3.3,0.6, 2.18,1.1,0.2, 1.18,1.54,0.98, 1.56,0.3,3.6, 1.613,0.801,4.374, 2.6,2.4,2.3, 2.31232,2.3933985,1.553255};
 631   for(int i=0;i<24;i++)
 632     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[i],resToTest->getIJ(0,i),1e-14);
 633   resToTest->decrRef();
 634   //
 635   m3->decrRef();
 636   f->decrRef();
 637 }
 638
 639 /*!
 640  * Not activated test ! To be implemented !
 641  */
 642 void MEDCouplingBasicsTest4::testQ1Localization1()
 643 {
 644   MEDCouplingUMesh *m=buildHexa8Mesh_1();
 645   MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
 646   DataArrayDouble *da=DataArrayDouble::New();
 647   const double vals1[27]={1.0,3.0,4.0,1.0,3.0,4.0,3.0,2.0,5.0,1.0,3.0,4.0,1.0,3.0,4.0,3.0,2.0,5.0,1.0,3.0,4.0,1.0,3.0,4.0,3.0,2.0,5.0};
 648   da->alloc(27,1);
 649   std::copy(vals1,vals1+27,da->getPointer());
 650   f->setMesh(m);
 651   f->setArray(da);
 652   da->decrRef();
 653   //
 654   const double point1[3]={0.25,0.75,0.25};
 655   //const double points1[6]={0.25,0.75,0.25,1.0,1.0,1.0};
 656   double res1[3];
 657   f->getValueOn(point1,res1);
 658   //
 659   f->decrRef();
 660   m->decrRef();
 661 }
 662
 663 void MEDCouplingBasicsTest4::testP2Localization1()
 664 {
 665   MEDCouplingUMesh *m=MEDCouplingUMesh::New("testP2",2);
 666   const double coords[12]={0.,2.,3.5,0.,4.5,1.5,1.2,0.32,3.4,1.,2.1,2.4};
 667   const mcIdType conn[6]={0,1,2,3,4,5};
 668   DataArrayDouble *coo=DataArrayDouble::New();
 669   coo->alloc(6,2);
 670   std::copy(coords,coords+12,coo->getPointer());
 671   m->setCoords(coo);
 672   coo->decrRef();
 673   m->allocateCells(1);
 674   m->insertNextCell(INTERP_KERNEL::NORM_TRI6,6,conn);
 675   m->finishInsertingCells();
 676   //
 677   MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
 678   f->setMesh(m);
 679   DataArrayDouble *da=DataArrayDouble::New();
 680   da->alloc(6,3);
 681   const double vals1[18]={1.2,2.3,3.4, 2.2,3.3,4.4, 3.2,4.3,5.4, 4.2,5.3,6.4, 5.2,6.3,7.4, 6.2,7.3,8.4};
 682   std::copy(vals1,vals1+18,da->getPointer());
 683   f->setArray(da);
 684   da->decrRef();
 685   //
 686   const double loc[2]={2.27,1.3};
 687   DataArrayDouble *locs=f->getValueOnMulti(loc,1);
 688   const double expected1[3]={6.0921164547752236, 7.1921164547752232, 8.2921164547752255};
 689   for(int i=0;i<3;i++)
 690     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],locs->getIJ(0,i),1e-12);
 691   locs->decrRef();
 692   //
 693   m->decrRef();
 694   f->decrRef();
 695 }
 696
 697 void MEDCouplingBasicsTest4::testP2Localization2()
 698 {
 699   MEDCouplingUMesh *m=MEDCouplingUMesh::New("testP2_2",3);
 700   const double coords[30]={0.33312787792955395, -0.35155740179580952, -0.03567564825034563, 1.307146326477638, -0.57234557776250305, -0.08608044208272235, 0.5551834466499993, 0.62324964668794192, -0.014638951108536295, 0.37761817224442129, -0.38324019806913578, 0.96283164472856886, 0.79494856035658679, -0.40628057809270046, 0.0021004190225864614, 1.023740446371799, 0.07665912970471335, -0.072889657161871096, 0.54564584619517376, 0.11132872093429744, 0.039647326652013051, 0.27164784387819052, -0.42018012100866675, 0.46563376500745146, 0.89501965094896418, -0.56148455362735061, 0.43337469695473035, 0.49118025152924394, 0.093884938060727313, 0.47216346905220891};
 701   const mcIdType conn[10]={0,1,2,3,4,5,6,7,8,9};
 702   DataArrayDouble *coo=DataArrayDouble::New();
 703   coo->alloc(10,3);
 704   std::copy(coords,coords+30,coo->getPointer());
 705   m->setCoords(coo);
 706   coo->decrRef();
 707   m->allocateCells(1);
 708   m->insertNextCell(INTERP_KERNEL::NORM_TETRA10,10,conn);
 709   m->finishInsertingCells();
 710   //
 711   MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
 712   f->setMesh(m);
 713   DataArrayDouble *da=DataArrayDouble::New();
 714   da->alloc(10,1);
 715   const double vals1[10]={1.1,2.1,3.1,4.1,5.2,6.2,7.2,8.2,9.2,10.2};
 716   std::copy(vals1,vals1+10,da->getPointer());
 717   f->setArray(da);
 718   da->decrRef();
 719   //
 720   const double loc[3]={0.64637931739890486, -0.16185896817550552, 0.22678966365273748};
 721   DataArrayDouble *locs=f->getValueOnMulti(loc,1);
 722   const double expected1[1]={10.0844021968047};
 723   for(int i=0;i<1;i++)
 724     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],locs->getIJ(0,i),1e-12);
 725   locs->decrRef();
 726   //
 727   m->decrRef();
 728   f->decrRef();
 729 }
 730
 731 void MEDCouplingBasicsTest4::testGetValueOn2()
 732 {
 733   MEDCouplingUMesh *m=build2DTargetMesh_1();
 734   MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
 735   f->setMesh(m);
 736   DataArrayDouble *arr=DataArrayDouble::New();
 737   std::size_t nbOfCells=m->getNumberOfCells();
 738   arr->alloc(nbOfCells,3);
 739   f->setArray(arr);
 740   arr->decrRef();
 741   const double values1[15]={7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.};
 742   std::copy(values1,values1+15,arr->getPointer());
 743   const double loc[10]={-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45};
 744   f->checkConsistencyLight();
 745   DataArrayDouble *locs=f->getValueOnMulti(loc,5);
 746  CPPUNIT_ASSERT_EQUAL(5,(int)locs->getNumberOfTuples());
 747  CPPUNIT_ASSERT_EQUAL(3,(int)locs->getNumberOfComponents());
 748   for(int j=0;j<15;j++)
 749     CPPUNIT_ASSERT_DOUBLES_EQUAL(values1[j],locs->getIJ(0,j),1e-12);
 750   locs->decrRef();
 751   f->decrRef();
 752   // Testing ON_NODES
 753   f=MEDCouplingFieldDouble::New(ON_NODES,NO_TIME);
 754   f->setMesh(m);
 755   arr=DataArrayDouble::New();
 756   mcIdType nbOfNodes=m->getNumberOfNodes();
 757   arr->alloc(nbOfNodes,3);
 758   f->setArray(arr);
 759   arr->decrRef();
 760   const double values2[27]={7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.,12.,112.,10012.,13.,113.,10013.,14.,114.,10014.,15.,115.,10015.};
 761   std::copy(values2,values2+27,arr->getPointer());
 762   const double loc2[8]={0.5432,-0.2432, 0.5478,0.1528, 0.5432,-0.2432, 0.5432,-0.2432};
 763   const double expected2[12]={9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124, 9.0272, 109.0272, 10009.0272, 9.0272, 109.0272, 10009.0272};
 764   f->checkConsistencyLight();
 765   locs=f->getValueOnMulti(loc2,4);
 766  CPPUNIT_ASSERT_EQUAL(4,(int)locs->getNumberOfTuples());
 767  CPPUNIT_ASSERT_EQUAL(3,(int)locs->getNumberOfComponents());
 768   for(int i=0;i<12;i++)
 769     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],locs->getIJ(0,i),1e-12);
 770   f->decrRef();
 771   locs->decrRef();
 772   //
 773   m->decrRef();
 774 }
 775
 776 void MEDCouplingBasicsTest4::testDAIGetIdsNotEqual1()
 777 {
 778   DataArrayIdType *d=DataArrayIdType::New();
 779   const mcIdType vals1[10]={2,3,5,6,8,5,5,6,1,-5};
 780   d->alloc(10,1);
 781   std::copy(vals1,vals1+10,d->getPointer());
 782   DataArrayIdType *d2=d->findIdsNotEqual(5);
 783  CPPUNIT_ASSERT_EQUAL(7,(int)d2->getNumberOfTuples());
 784  CPPUNIT_ASSERT_EQUAL(1,(int)d2->getNumberOfComponents());
 785   const mcIdType expected1[7]={0,1,3,4,7,8,9};
 786   for(int i=0;i<7;i++)
 787     CPPUNIT_ASSERT_EQUAL(expected1[i],d2->getIJ(0,i));
 788   d->rearrange(2);
 789   CPPUNIT_ASSERT_THROW(d->findIdsNotEqual(5),INTERP_KERNEL::Exception);
 790   const mcIdType vals2[3]={-4,5,6};
 791   std::vector<mcIdType> vals3(vals2,vals2+3);
 792   d->rearrange(1);
 793   DataArrayIdType *d3=d->findIdsNotEqualList(&vals3[0],&vals3[0]+vals3.size());
 794  CPPUNIT_ASSERT_EQUAL(5,(int)d3->getNumberOfTuples());
 795  CPPUNIT_ASSERT_EQUAL(1,(int)d3->getNumberOfComponents());
 796   const mcIdType expected2[5]={0,1,4,8,9};
 797   for(int i=0;i<5;i++)
 798     CPPUNIT_ASSERT_EQUAL(expected2[i],d3->getIJ(0,i));
 799   d3->decrRef();
 800   d->decrRef();
 801   d2->decrRef();
 802 }
 803
 804 void MEDCouplingBasicsTest4::testDAIComputeOffsets1()
 805 {
 806   DataArrayIdType *d=DataArrayIdType::New();
 807   const mcIdType vals1[6]={3,5,1,2,0,8};
 808   const mcIdType expected1[6]={0,3,8,9,11,11};
 809   d->alloc(6,1);
 810   std::copy(vals1,vals1+6,d->getPointer());
 811   d->computeOffsets();
 812  CPPUNIT_ASSERT_EQUAL(6,(int)d->getNumberOfTuples());
 813  CPPUNIT_ASSERT_EQUAL(1,(int)d->getNumberOfComponents());
 814   for(int i=0;i<6;i++)
 815     CPPUNIT_ASSERT_EQUAL(expected1[i],d->getIJ(0,i));
 816   d->decrRef();
 817 }
 818
 819 void MEDCouplingBasicsTest4::testUMeshHexagonPrism1()
 820 {
 821   const double coords[36]={
 822     0.8660254037844386, 0.5, 0.0, 0.0, 1.0, 0.0, -0.8660254037844386, 0.5, 0.0, -0.8660254037844386, -0.5, 0.0, 0.0, -1.0, 0.0, 0.8660254037844386, -0.5, 0.0,
 823     0.8660254037844386, 0.5, 2.0, 0.0, 1.0, 2.0, -0.8660254037844386, 0.5, 2.0, -0.8660254037844386, -0.5, 2.0, 0.0, -1.0, 2.0, 0.8660254037844386, -0.5, 2.0
 824   };
 825   const mcIdType conn[12]={1,2,3,4,5,0,7,8,9,10,11,6};
 826   MEDCouplingUMesh *mesh=MEDCouplingUMesh::New("MyFirstHexagonalPrism",3);
 827   DataArrayDouble *coo=DataArrayDouble::New();
 828   coo->alloc(12,3);
 829   std::copy(coords,coords+36,coo->getPointer());
 830   mesh->setCoords(coo);
 831   mesh->allocateCells(1);
 832   mesh->insertNextCell(INTERP_KERNEL::NORM_HEXGP12,12,conn);
 833   mesh->finishInsertingCells();
 834   coo->decrRef();
 835   //
 836   mesh->checkConsistencyLight();
 837   MEDCouplingFieldDouble *vols=mesh->getMeasureField(false);
 838  CPPUNIT_ASSERT_EQUAL(1,(int)vols->getNumberOfTuples());
 839  CPPUNIT_ASSERT_EQUAL(1,(int)vols->getNumberOfComponents());
 840   CPPUNIT_ASSERT_DOUBLES_EQUAL(-5.196152422706632,vols->getIJ(0,0),1e-12);
 841   DataArrayDouble *bary=mesh->computeCellCenterOfMass();
 842  CPPUNIT_ASSERT_EQUAL(1,(int)bary->getNumberOfTuples());
 843  CPPUNIT_ASSERT_EQUAL(3,(int)bary->getNumberOfComponents());
 844   const double expected1[3]={0.,0.,1.};
 845   for(int i=0;i<3;i++)
 846     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],bary->getIJ(0,i),1e-12);
 847   DataArrayIdType *d1=DataArrayIdType::New();
 848   DataArrayIdType *d2=DataArrayIdType::New();
 849   DataArrayIdType *d3=DataArrayIdType::New();
 850   DataArrayIdType *d4=DataArrayIdType::New();
 851   MEDCouplingUMesh *m2=mesh->buildDescendingConnectivity(d1,d2,d3,d4);
 852   CPPUNIT_ASSERT_EQUAL(8,(int)m2->getNumberOfCells());
 853   const mcIdType expected4[8][6]={{1,2,3,4,5,0},{7,6,11,10,9,8},{1,7,8,2},{2,8,9,3},{3,9,10,4},{4,10,11,5},{5,11,6,0},{0,6,7,1}};
 854   const INTERP_KERNEL::NormalizedCellType expected2[8]={INTERP_KERNEL::NORM_POLYGON, INTERP_KERNEL::NORM_POLYGON, INTERP_KERNEL::NORM_QUAD4, INTERP_KERNEL::NORM_QUAD4, INTERP_KERNEL::NORM_QUAD4, INTERP_KERNEL::NORM_QUAD4, INTERP_KERNEL::NORM_QUAD4, INTERP_KERNEL::NORM_QUAD4};
 855   const mcIdType expected3[8]={6,6,4,4,4,4,4,4};
 856   for(int i=0;i<8;i++)
 857     {
 858       CPPUNIT_ASSERT(m2->getTypeOfCell(i)==expected2[i]);
 859       std::vector<mcIdType> v;
 860       m2->getNodeIdsOfCell(i,v);
 861       CPPUNIT_ASSERT((int)v.size()==expected3[i]);
 862       CPPUNIT_ASSERT(std::equal(expected4[i],expected4[i]+expected3[i],v.begin()));
 863     }
 864   d1->decrRef();
 865   d2->decrRef();
 866   d3->decrRef();
 867   d4->decrRef();
 868   m2->decrRef();
 869   //
 870   mesh->convertAllToPoly();
 871   CPPUNIT_ASSERT(INTERP_KERNEL::NORM_POLYHED==mesh->getTypeOfCell(0));
 872   mesh->unPolyze();
 873   CPPUNIT_ASSERT(INTERP_KERNEL::NORM_HEXGP12==mesh->getTypeOfCell(0));
 874   CPPUNIT_ASSERT_EQUAL(ToIdType(13),mesh->getNodalConnectivityArrayLen());
 875   //
 876   vols->decrRef();
 877   bary->decrRef();
 878   mesh->decrRef();
 879 }
 880
 881 void MEDCouplingBasicsTest4::testDADCheckIsMonotonic()
 882 {
 883   DataArrayDouble *da=DataArrayDouble::New();
 884   const double vals[4]={-1.,1.01,2.03,6.};
 885   da->alloc(2,2);
 886   std::copy(vals,vals+4,da->getPointer());
 887   CPPUNIT_ASSERT_THROW(da->isMonotonic(true, 1e-12),INTERP_KERNEL::Exception);
 888   da->rearrange(1);
 889   CPPUNIT_ASSERT(da->isMonotonic(true, 1e-12));
 890   da->checkMonotonic(true, 1e-12);
 891   da->setIJ(2,0,6.1);
 892   CPPUNIT_ASSERT(!da->isMonotonic(true, 1e-12));
 893   CPPUNIT_ASSERT_THROW(da->checkMonotonic(true, 1e-12),INTERP_KERNEL::Exception);
 894   CPPUNIT_ASSERT_THROW(da->checkMonotonic(false, 1e-12),INTERP_KERNEL::Exception);
 895   da->setIJ(2,0,5.99);
 896   CPPUNIT_ASSERT(da->isMonotonic(true, 1e-12));
 897   CPPUNIT_ASSERT(!da->isMonotonic(true, 1e-1));
 898   da->decrRef();
 899 }
 900
 901 void MEDCouplingBasicsTest4::testCheckCoherencyDeeper1()
 902 {
 903   MEDCouplingUMesh *m=build3DSourceMesh_1();
 904   m->checkConsistencyLight();
 905   m->checkConsistency();
 906   m->getNodalConnectivity()->setIJ(8,0,-1);
 907   m->checkConsistencyLight();
 908   CPPUNIT_ASSERT_THROW(m->checkConsistency(),INTERP_KERNEL::Exception);
 909   m->getNodalConnectivity()->setIJ(8,0,-6);
 910   m->checkConsistencyLight();
 911   CPPUNIT_ASSERT_THROW(m->checkConsistency(),INTERP_KERNEL::Exception);
 912   m->getNodalConnectivity()->setIJ(8,0,9);//9>=NbOfNodes
 913   m->checkConsistencyLight();
 914   CPPUNIT_ASSERT_THROW(m->checkConsistency(),INTERP_KERNEL::Exception);
 915   m->getNodalConnectivity()->setIJ(8,0,8);//OK
 916   m->checkConsistencyLight();
 917   m->checkConsistency();
 918   const mcIdType elts[2]={1,5};
 919   std::vector<mcIdType> eltsV(elts,elts+2);
 920   m->convertToPolyTypes(&eltsV[0],&eltsV[0]+eltsV.size());
 921   m->checkConsistencyLight();
 922   m->checkConsistency();
 923   m->getNodalConnectivity()->setIJ(2,0,9);//9>=NbOfNodes
 924   m->checkConsistencyLight();
 925   CPPUNIT_ASSERT_THROW(m->checkConsistency(),INTERP_KERNEL::Exception);
 926   m->getNodalConnectivity()->setIJ(2,0,-3);
 927   m->checkConsistencyLight();
 928   CPPUNIT_ASSERT_THROW(m->checkConsistency(),INTERP_KERNEL::Exception);
 929   m->getNodalConnectivity()->setIJ(2,0,-1);
 930   m->checkConsistencyLight();
 931   CPPUNIT_ASSERT_THROW(m->checkConsistency(),INTERP_KERNEL::Exception);//Throw because cell#0 is not a polyhedron
 932   m->getNodalConnectivity()->setIJ(2,0,4);
 933   m->checkConsistencyLight();
 934   m->checkConsistency();
 935   m->getNodalConnectivity()->setIJ(7,0,-1);
 936   m->checkConsistencyLight();
 937   m->checkConsistency();//OK because we are in polyhedron connec
 938   m->getNodalConnectivity()->setIJ(36,0,14);
 939   m->checkConsistencyLight();
 940   CPPUNIT_ASSERT_THROW(m->checkConsistency(),INTERP_KERNEL::Exception);//Throw because now cell 5 is a TETRA4 (14) so mismatch of number index and static type.
 941   m->decrRef();
 942 }
 943
 944 void MEDCouplingBasicsTest4::testUnPolyze2()
 945 {
 946   MEDCouplingUMesh *m=MEDCouplingUMesh::New("jjj",3);
 947   DataArrayDouble *coo=DataArrayDouble::New();
 948   coo->alloc(4,3);
 949   coo->rearrange(1);
 950   coo->iota(0);
 951   coo->rearrange(3);
 952   m->setCoords(coo);
 953   coo->decrRef();
 954   m->allocateCells(2);
 955   const mcIdType conn[4]={0,1,2,3};
 956   m->insertNextCell(INTERP_KERNEL::NORM_TETRA4,4,conn);
 957   m->insertNextCell(INTERP_KERNEL::NORM_TETRA4,4,conn);
 958   m->finishInsertingCells();
 959   std::vector<const MEDCouplingUMesh *> ms(4,m);
 960   MEDCouplingUMesh *m2=MEDCouplingUMesh::MergeUMeshesOnSameCoords(ms);
 961   std::vector<mcIdType> temp(1,2);
 962   m2->convertToPolyTypes(&temp[0],&temp[0]+temp.size());
 963   m2->unPolyze();
 964   CPPUNIT_ASSERT(INTERP_KERNEL::NORM_TETRA4==m2->getTypeOfCell(2));
 965   CPPUNIT_ASSERT_EQUAL(ToIdType(40),m2->getNodalConnectivityArrayLen());
 966   std::vector<mcIdType> temp2;
 967   m2->getNodeIdsOfCell(2,temp2);
 968   CPPUNIT_ASSERT(4==(int)temp2.size());
 969   CPPUNIT_ASSERT(std::equal(conn,conn+4,temp2.begin()));
 970   m2->checkConsistency();
 971   MEDCouplingMesh *m3=m2->deepCopy();
 972   m2->unPolyze();
 973   CPPUNIT_ASSERT(m3->isEqual(m2,1e-12));
 974   m3->decrRef();
 975   m->decrRef();
 976   m2->decrRef();
 977 }
 978
 979 void MEDCouplingBasicsTest4::testDACpyFrom1()
 980 {
 981   DataArrayDouble *d=DataArrayDouble::New();
 982   d->alloc(12,1);
 983   d->iota(14.);
 984   d->rearrange(3);
 985   d->setName("Toto");
 986   d->setInfoOnComponent(0,"X [m]");
 987   d->setInfoOnComponent(1,"Y [m]");
 988   d->setInfoOnComponent(2,"Z [m]");
 989   //
 990   DataArrayDouble *d1=DataArrayDouble::New();
 991   CPPUNIT_ASSERT(!d->isEqual(*d1,1e-12));
 992   d1->deepCopyFrom(*d);
 993   CPPUNIT_ASSERT(d->isEqual(*d1,1e-12));
 994   d1->deepCopyFrom(*d);
 995   CPPUNIT_ASSERT(d->isEqual(*d1,1e-12));
 996   d1->rearrange(2);
 997   CPPUNIT_ASSERT(!d->isEqual(*d1,1e-12));
 998   d1->deepCopyFrom(*d);
 999   CPPUNIT_ASSERT(d->isEqual(*d1,1e-12));
1000   //
1001   MCAuto<DataArrayInt> d2=d->convertToIntArr();
1002   DataArrayInt *d4=DataArrayInt::New();
1003   CPPUNIT_ASSERT(!d2->isEqual(*d4));
1004   d4->deepCopyFrom(*d2);
1005   CPPUNIT_ASSERT(d2->isEqual(*d4));
1006   d4->deepCopyFrom(*d2);
1007   CPPUNIT_ASSERT(d2->isEqual(*d4));
1008   d4->rearrange(2);
1009   CPPUNIT_ASSERT(!d2->isEqual(*d4));
1010   d4->deepCopyFrom(*d2);
1011   CPPUNIT_ASSERT(d2->isEqual(*d4));
1012   //
1013   d->decrRef();
1014   d1->decrRef();
1015   d4->decrRef();
1016 }
1017
1018 void MEDCouplingBasicsTest4::testDAITransformWithIndArr1()
1019 {
1020   const mcIdType tab1[4]={17,18,22,19};
1021   const mcIdType tab2[12]={0,1,1,3,3,0,1,3,2,2,3,0};
1022   const mcIdType expected[12]={17,18,18,19,19,17,18,19,22,22,19,17};
1023   DataArrayIdType *d=DataArrayIdType::New();
1024   d->alloc(4,1);
1025   std::copy(tab1,tab1+4,d->getPointer());
1026   DataArrayIdType *d1=DataArrayIdType::New();
1027   d1->alloc(12,1);
1028   std::copy(tab2,tab2+12,d1->getPointer());
1029   //
1030   d1->transformWithIndArr(d->getConstPointer(),d->getConstPointer()+d->getNbOfElems());
1031  CPPUNIT_ASSERT_EQUAL(12,(int)d1->getNumberOfTuples());
1032  CPPUNIT_ASSERT_EQUAL(1,(int)d1->getNumberOfComponents());
1033   for(int i=0;i<12;i++)
1034     CPPUNIT_ASSERT_EQUAL(expected[i],d1->getIJ(i,0));
1035   //
1036   d->decrRef();
1037   d1->decrRef();
1038 }
1039
1040 void MEDCouplingBasicsTest4::testDAIBuildPermArrPerLevel1()
1041 {
1042   const mcIdType arr[12]={2,0,1,1,0,1,2,0,1,1,0,0};
1043   const mcIdType expected1[12]={10,0,5,6,1,7,11,2,8,9,3,4};
1044   DataArrayIdType *da=DataArrayIdType::New();
1045   da->alloc(12,1);
1046   std::copy(arr,arr+12,da->getPointer());
1047   DataArrayIdType *da2=da->buildPermArrPerLevel();
1048  CPPUNIT_ASSERT_EQUAL(12,(int)da2->getNumberOfTuples());
1049  CPPUNIT_ASSERT_EQUAL(1,(int)da2->getNumberOfComponents());
1050   for(int i=0;i<12;i++)
1051     CPPUNIT_ASSERT_EQUAL(expected1[i],da2->getIJ(i,0));
1052   da->decrRef();
1053   da2->decrRef();
1054 }
1055
1056 void MEDCouplingBasicsTest4::testDAIOperations1()
1057 {
1058   const mcIdType arr1[12]={-1,-2,4,7,3,2,6,6,4,3,0,1};
1059   DataArrayIdType *da=DataArrayIdType::New();
1060   da->alloc(4,3);
1061   std::copy(arr1,arr1+12,da->getPointer());
1062   DataArrayIdType *da1=DataArrayIdType::New();
1063   da1->alloc(12,1);
1064   da1->iota(2);
1065   CPPUNIT_ASSERT_THROW(DataArrayIdType::Add(da,da1),INTERP_KERNEL::Exception);//not same number of tuples/Components
1066   da1->rearrange(3);
1067   DataArrayIdType *da2=DataArrayIdType::Add(da,da1);
1068  CPPUNIT_ASSERT_EQUAL(4,(int)da2->getNumberOfTuples());
1069  CPPUNIT_ASSERT_EQUAL(3,(int)da2->getNumberOfComponents());
1070   const mcIdType expected1[12]={1,1,8,12,9,9,14,15,14,14,12,14};
1071   for(int i=0;i<12;i++)
1072     CPPUNIT_ASSERT_EQUAL(expected1[i],da2->getIJ(0,i));
1073   da2->decrRef();
1074   da1->substractEqual(da);
1075   const mcIdType expected2[12]={3,5,0,-2,3,5,2,3,6,8,12,12};
1076   for(int i=0;i<12;i++)
1077     CPPUNIT_ASSERT_EQUAL(expected2[i],da1->getIJ(0,i));
1078   da1->rearrange(1); da1->iota(2); da1->rearrange(3);
1079   da1->addEqual(da);
1080   for(int i=0;i<12;i++)
1081     CPPUNIT_ASSERT_EQUAL(expected1[i],da1->getIJ(0,i));
1082   da1->rearrange(1); da1->iota(2); da1->rearrange(3);
1083   da2=DataArrayIdType::Multiply(da,da1);
1084  CPPUNIT_ASSERT_EQUAL(4,(int)da2->getNumberOfTuples());
1085  CPPUNIT_ASSERT_EQUAL(3,(int)da2->getNumberOfComponents());
1086   const mcIdType expected3[12]={-2,-6,16,35,18,14,48,54,40,33,0,13};
1087   for(int i=0;i<12;i++)
1088     CPPUNIT_ASSERT_EQUAL(expected3[i],da2->getIJ(0,i));
1089   da2->decrRef();
1090   da->divideEqual(da1);
1091  CPPUNIT_ASSERT_EQUAL(4,(int)da->getNumberOfTuples());
1092  CPPUNIT_ASSERT_EQUAL(3,(int)da->getNumberOfComponents());
1093   const mcIdType expected4[12]={0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0};
1094   for(int i=0;i<12;i++)
1095     CPPUNIT_ASSERT_EQUAL(expected4[i],da->getIJ(0,i));
1096   std::copy(arr1,arr1+12,da->getPointer());
1097   da1->multiplyEqual(da);
1098  CPPUNIT_ASSERT_EQUAL(4,(int)da1->getNumberOfTuples());
1099  CPPUNIT_ASSERT_EQUAL(3,(int)da1->getNumberOfComponents());
1100   for(int i=0;i<12;i++)
1101     CPPUNIT_ASSERT_EQUAL(expected3[i],da1->getIJ(0,i));
1102   da1->rearrange(1); da1->iota(2); da1->rearrange(3);
1103   da2=DataArrayIdType::Divide(da,da1);
1104  CPPUNIT_ASSERT_EQUAL(4,(int)da2->getNumberOfTuples());
1105  CPPUNIT_ASSERT_EQUAL(3,(int)da2->getNumberOfComponents());
1106   for(int i=0;i<12;i++)
1107     CPPUNIT_ASSERT_EQUAL(expected4[i],da2->getIJ(0,i));
1108   da2->decrRef();
1109   da1->applyInv(321);
1110  CPPUNIT_ASSERT_EQUAL(4,(int)da1->getNumberOfTuples());
1111  CPPUNIT_ASSERT_EQUAL(3,(int)da1->getNumberOfComponents());
1112   const mcIdType expected5[12]={160,107,80,64,53,45,40,35,32,29,26,24};
1113   for(int i=0;i<12;i++)
1114     CPPUNIT_ASSERT_EQUAL(expected5[i],da1->getIJ(0,i));
1115   da1->applyDivideBy(2);
1116  CPPUNIT_ASSERT_EQUAL(4,(int)da1->getNumberOfTuples());
1117  CPPUNIT_ASSERT_EQUAL(3,(int)da1->getNumberOfComponents());
1118   const mcIdType expected6[12]={80,53,40,32,26,22,20,17,16,14,13,12};
1119   for(int i=0;i<12;i++)
1120     CPPUNIT_ASSERT_EQUAL(expected6[i],da1->getIJ(0,i));
1121   const mcIdType expected7[12]={3,4,5,4,5,1,6,3,2,0,6,5};
1122   da1->applyModulus(7);
1123   for(int i=0;i<12;i++)
1124     CPPUNIT_ASSERT_EQUAL(expected7[i],da1->getIJ(0,i));
1125   da1->applyLin(1,1);
1126   const mcIdType expected8[12]={3,3,3,3,3,1,3,3,0,0,3,3};
1127   da1->applyRModulus(3);
1128   for(int i=0;i<12;i++)
1129     CPPUNIT_ASSERT_EQUAL(expected8[i],da1->getIJ(0,i));
1130   //
1131   da1->decrRef();
1132   da->decrRef();
1133 }
1134
1135 void MEDCouplingBasicsTest4::testEmulateMEDMEMBDC1()
1136 {
1137   MEDCouplingUMesh *m1=0;
1138   MEDCouplingUMesh *m=buildPointe_1(m1);
1139   DataArrayIdType *da1=DataArrayIdType::New();
1140   DataArrayIdType *da2=DataArrayIdType::New();
1141   DataArrayIdType *da3=0;
1142   DataArrayIdType *da4=0;
1143   DataArrayIdType *da5=0;
1144   DataArrayIdType *da0=0;
1145   MEDCouplingUMesh *m2=m->emulateMEDMEMBDC(m1,da1,da2,da3,da4,da5,da0);
1146   const mcIdType expected0[47]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,36,37,32,33,34,35,38,39,40,41,42,43,44,45,46};
1147   const mcIdType expected1[6]={1,32,29,23,41,36};
1148  CPPUNIT_ASSERT_EQUAL(47,(int)da0->getNumberOfTuples());
1149  CPPUNIT_ASSERT_EQUAL(1,(int)da0->getNumberOfComponents());
1150   for(int i=0;i<47;i++)
1151     CPPUNIT_ASSERT_EQUAL(expected0[i],da0->getIJ(0,i));
1152  CPPUNIT_ASSERT_EQUAL(6,(int)da5->getNumberOfTuples());
1153  CPPUNIT_ASSERT_EQUAL(1,(int)da5->getNumberOfComponents());
1154   for(int i=0;i<6;i++)
1155     CPPUNIT_ASSERT_EQUAL(expected1[i],da5->getIJ(0,i));
1156   const mcIdType expected2[70]={0,1,2,3,4,0,5,6,7,4,8,9,1,7,10,11,12,13,14,5,15,16,17,8,18,19,20,10,21,22,23,2,13,24,25,21,16,26,27,12,19,28,29,15,22,30,31,18,36,26,28,30,24,37,32,33,34,35,38,36,39,40,41,42,37,38,43,44,45,46};
1157  CPPUNIT_ASSERT_EQUAL(70,(int)da1->getNumberOfTuples());
1158  CPPUNIT_ASSERT_EQUAL(1,(int)da1->getNumberOfComponents());
1159   for(int i=0;i<70;i++)
1160     CPPUNIT_ASSERT_EQUAL(expected2[i],da1->getIJ(0,i));
1161   const mcIdType expected3[17]={0,4,8,12,16,20,24,28,32,36,40,44,48,53,58,64,70};
1162  CPPUNIT_ASSERT_EQUAL(17,(int)da2->getNumberOfTuples());
1163  CPPUNIT_ASSERT_EQUAL(1,(int)da2->getNumberOfComponents());
1164   for(int i=0;i<17;i++)
1165     CPPUNIT_ASSERT_EQUAL(expected3[i],da2->getIJ(0,i));
1166   const mcIdType expected4[48]={0,2,4,6,7,9,11,12,14,16,17,19,20,22,24,25,27,29,30,32,34,35,37,39,40,42,43,45,46,48,49,51,52,53,54,55,56,58,60,62,63,64,65,66,67,68,69,70};
1167   //const mcIdType expected4[48]={0,2,4,6,7,9,11,12,14,16,17,19,20,22,24,25,27,29,30,32,34,35,37,39,40,42,43,45,46,48,49,51,52,54,56,57,58,59,60,62,63,64,65,66,67,68,69,70};
1168  CPPUNIT_ASSERT_EQUAL(48,(int)da4->getNumberOfTuples());
1169  CPPUNIT_ASSERT_EQUAL(1,(int)da4->getNumberOfComponents());
1170   for(int i=0;i<48;i++)
1171     CPPUNIT_ASSERT_EQUAL(expected4[i],da4->getIJ(0,i));
1172   const mcIdType expected5[70]={0,1,0,3,0,7,0,1,2,1,4,1,2,3,2,5,2,3,6,3,4,9,4,8,4,5,10,5,9,5,6,11,6,10,6,7,8,7,11,7,8,12,8,9,12,9,10,12,10,11,12,11,13,13,13,13,12,14,13,15,14,15,14,14,14,14,15,15,15,15};
1173  CPPUNIT_ASSERT_EQUAL(70,(int)da3->getNumberOfTuples());
1174  CPPUNIT_ASSERT_EQUAL(1,(int)da3->getNumberOfComponents());
1175   for(int i=0;i<70;i++)
1176     CPPUNIT_ASSERT_EQUAL(expected5[i],da3->getIJ(0,i));
1177   //
1178   da0->decrRef();
1179   da1->decrRef();
1180   da2->decrRef();
1181   da3->decrRef();
1182   da4->decrRef();
1183   da5->decrRef();
1184   //
1185   m2->decrRef();
1186   m1->decrRef();
1187   m->decrRef();
1188 }
1189
1190 void MEDCouplingBasicsTest4::testGetLevArrPerCellTypes1()
1191 {
1192   MEDCouplingUMesh *m1=0;
1193   MEDCouplingUMesh *m=buildPointe_1(m1);
1194   m1->decrRef();
1195   DataArrayIdType *d0=DataArrayIdType::New();
1196   DataArrayIdType *d1=DataArrayIdType::New();
1197   DataArrayIdType *d2=DataArrayIdType::New();
1198   DataArrayIdType *d3=DataArrayIdType::New();
1199   m1=m->buildDescendingConnectivity(d0,d1,d2,d3);
1200   d0->decrRef(); d1->decrRef(); d2->decrRef(); d3->decrRef();
1201   INTERP_KERNEL::NormalizedCellType order[2]={INTERP_KERNEL::NORM_TRI3,INTERP_KERNEL::NORM_QUAD4};
1202   DataArrayIdType *da1=0;
1203   DataArrayIdType *da0=m1->getLevArrPerCellTypes(order,order+2,da1);
1204   const mcIdType expected0[47]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1};
1205   const mcIdType expected1[47]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,36,37,32,33,34,35,38,39,40,41,42,43,44,45,46};
1206   CPPUNIT_ASSERT_EQUAL(47,(int)da0->getNumberOfTuples());
1207   CPPUNIT_ASSERT_EQUAL(1,(int)da0->getNumberOfComponents());
1208   for(int i=0;i<47;i++)
1209     CPPUNIT_ASSERT_EQUAL(expected0[i],da0->getIJ(0,i));
1210   CPPUNIT_ASSERT_EQUAL(2,(int)da1->getNumberOfTuples());
1211   CPPUNIT_ASSERT_EQUAL(1,(int)da1->getNumberOfComponents());
1212   CPPUNIT_ASSERT_EQUAL(36,(int)da1->getIJ(0,0));//36 TRI3
1213   CPPUNIT_ASSERT_EQUAL(11,(int)da1->getIJ(1,0));//11 QUAD4
1214   //
1215   DataArrayIdType *da2=da0->buildPermArrPerLevel();
1216   //
1217   CPPUNIT_ASSERT_EQUAL(47,(int)da2->getNumberOfTuples());
1218   CPPUNIT_ASSERT_EQUAL(1,(int)da2->getNumberOfComponents());
1219   for(int i=0;i<47;i++)
1220     CPPUNIT_ASSERT_EQUAL(expected1[i],da2->getIJ(0,i));
1221   da2->decrRef();
1222   da0->decrRef();
1223   da1->decrRef();
1224   //
1225   m->decrRef();
1226   m1->decrRef();
1227 }
1228
1229 void MEDCouplingBasicsTest4::testSortCellsInMEDFileFrmt1()
1230 {
1231   MEDCouplingUMesh *m1=0;
1232   MEDCouplingUMesh *m=buildPointe_1(m1);
1233   MEDCouplingUMesh *m2=(MEDCouplingUMesh *)m->deepCopy();
1234   m->setCoords(0);
1235   const mcIdType vals[16]={0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13};
1236   DataArrayIdType *da=DataArrayIdType::New();
1237   da->alloc(16,1);
1238   std::copy(vals,vals+16,da->getPointer());
1239   DataArrayIdType *daa=da->invertArrayN2O2O2N(16);
1240   m->renumberCells(daa->getConstPointer(),false);
1241   daa->decrRef();
1242   DataArrayIdType *da2=m->sortCellsInMEDFileFrmt();
1243   CPPUNIT_ASSERT(m2->isEqual(m2,1e-12));
1244   CPPUNIT_ASSERT(da->isEqual(*da2));
1245   m2->decrRef();
1246   da2->decrRef();
1247   da->decrRef();
1248   m1->decrRef();
1249   m->decrRef();
1250 }
1251
1252 void MEDCouplingBasicsTest4::testBuildPartAndReduceNodes1()
1253 {
1254   MEDCouplingMesh *m=build2DTargetMesh_1();
1255   const mcIdType arr[2]={1,0};
1256   DataArrayIdType *da;
1257   MEDCouplingMesh *m2=m->buildPartAndReduceNodes(arr,arr+2,da);
1258   CPPUNIT_ASSERT_EQUAL(5,(int)m2->getNumberOfNodes());
1259   CPPUNIT_ASSERT_EQUAL(2,(int)m2->getNumberOfCells());
1260   MEDCouplingFieldDouble *f=m2->getMeasureField(true);
1261   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.125,f->getArray()->getIJ(0,0),1e-12);
1262   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.25,f->getArray()->getIJ(1,0),1e-12);
1263   f->decrRef();
1264   da->decrRef();
1265   m2->decrRef();
1266   m->decrRef();
1267 }
1268
1269 void MEDCouplingBasicsTest4::testDAITransformWithIndArrR1()
1270 {
1271   const mcIdType tab1[6]={2,4,5,3,6,7};
1272   const mcIdType tab2[12]={-1,-1,0,1,2,3,4,5,-1,-1,-1,-1};
1273   const mcIdType expected[6]={0,3,1,2,4,5};
1274   DataArrayIdType *d=DataArrayIdType::New();
1275   d->alloc(6,1);
1276   std::copy(tab1,tab1+6,d->getPointer());
1277   DataArrayIdType *d1=DataArrayIdType::New();
1278   d1->alloc(12,1);
1279   std::copy(tab2,tab2+12,d1->getPointer());
1280   //
1281   DataArrayIdType *d3=d->transformWithIndArrR(d1->getConstPointer(),d1->getConstPointer()+d1->getNbOfElems());
1282  CPPUNIT_ASSERT_EQUAL(6,(int)d3->getNumberOfTuples());
1283  CPPUNIT_ASSERT_EQUAL(1,(int)d3->getNumberOfComponents());
1284   for(int i=0;i<6;i++)
1285     CPPUNIT_ASSERT_EQUAL(expected[i],d3->getIJ(i,0));
1286   d3->decrRef();
1287   //
1288   d->decrRef();
1289   d1->decrRef();
1290 }
1291
1292 void MEDCouplingBasicsTest4::testDAISplitByValueRange1()
1293 {
1294   const mcIdType val1[9]={6,5,0,3,2,7,8,1,4};
1295   const mcIdType val2[3]={0,4,9};
1296   DataArrayIdType *d=DataArrayIdType::New();
1297   d->alloc(9,1);
1298   std::copy(val1,val1+9,d->getPointer());
1299   DataArrayIdType *ee=0,*f=0,*g=0;
1300   d->splitByValueRange(val2,val2+3,ee,f,g);
1301  CPPUNIT_ASSERT_EQUAL(9,(int)ee->getNumberOfTuples());
1302  CPPUNIT_ASSERT_EQUAL(1,(int)ee->getNumberOfComponents());
1303  CPPUNIT_ASSERT_EQUAL(9,(int)f->getNumberOfTuples());
1304  CPPUNIT_ASSERT_EQUAL(1,(int)f->getNumberOfComponents());
1305  CPPUNIT_ASSERT_EQUAL(2,(int)g->getNumberOfTuples());
1306  CPPUNIT_ASSERT_EQUAL(1,(int)g->getNumberOfComponents());
1307   //
1308   const mcIdType expected1[9]={1,1,0,0,0,1,1,0,1};
1309   const mcIdType expected2[9]={2,1,0,3,2,3,4,1,0};
1310   for(int i=0;i<9;i++)
1311     {
1312       CPPUNIT_ASSERT_EQUAL(expected1[i],ee->getIJ(i,0));
1313       CPPUNIT_ASSERT_EQUAL(expected2[i],f->getIJ(i,0));
1314     }
1315   CPPUNIT_ASSERT_EQUAL(0,(int)g->getIJ(0,0));
1316   CPPUNIT_ASSERT_EQUAL(1,(int)g->getIJ(1,0));
1317   //
1318   ee->decrRef();
1319   f->decrRef();
1320   g->decrRef();
1321   //
1322   d->setIJ(6,0,9);
1323   CPPUNIT_ASSERT_THROW(d->splitByValueRange(val2,val2+3,ee,f,g),INTERP_KERNEL::Exception);
1324   //
1325   d->decrRef();
1326 }
1327
1328 void MEDCouplingBasicsTest4::testUMeshSplitProfilePerType1()
1329 {
1330   const mcIdType val0[5]={2,0,1,3,4};
1331   MEDCouplingUMesh *m=build2DTargetMesh_1();
1332   m->renumberCells(val0,false);
1333   std::vector<mcIdType> code;
1334   std::vector<DataArrayIdType *> idsInPflPerType;
1335   std::vector<DataArrayIdType *> pfls;
1336   //
1337   const mcIdType val1[3]={0,2,3};
1338   DataArrayIdType *d=DataArrayIdType::New();
1339   d->alloc(3,1);
1340   d->setName("sup");
1341   std::copy(val1,val1+3,d->getPointer());
1342   m->splitProfilePerType(d,code,idsInPflPerType,pfls);
1343   CPPUNIT_ASSERT_EQUAL(6,(int)code.size());
1344   CPPUNIT_ASSERT_EQUAL(2,(int)idsInPflPerType.size());
1345   const mcIdType expected1[6]={3,1,0, 4,2,1};
1346   for(int i=0;i<6;i++)
1347     CPPUNIT_ASSERT_EQUAL(expected1[i],code[i]);
1348   CPPUNIT_ASSERT_EQUAL(1,(int)idsInPflPerType[0]->getNumberOfTuples());
1349   CPPUNIT_ASSERT_EQUAL(0,(int)idsInPflPerType[0]->getIJ(0,0));
1350   CPPUNIT_ASSERT_EQUAL(2,(int)idsInPflPerType[1]->getNumberOfTuples());
1351   CPPUNIT_ASSERT_EQUAL(1,(int)idsInPflPerType[1]->getIJ(0,0));
1352   CPPUNIT_ASSERT_EQUAL(2,(int)idsInPflPerType[1]->getIJ(1,0));
1353   idsInPflPerType[0]->decrRef();
1354   idsInPflPerType[1]->decrRef();
1355   CPPUNIT_ASSERT_EQUAL(2,(int)pfls.size());
1356   CPPUNIT_ASSERT(std::string("sup")==pfls[0]->getName());
1357   CPPUNIT_ASSERT_EQUAL(1,(int)pfls[0]->getNumberOfTuples());
1358   CPPUNIT_ASSERT_EQUAL(0,(int)pfls[0]->getIJ(0,0));
1359   CPPUNIT_ASSERT(std::string("sup")==pfls[1]->getName());
1360   CPPUNIT_ASSERT_EQUAL(2,(int)pfls[1]->getNumberOfTuples());
1361   CPPUNIT_ASSERT_EQUAL(0,(int)pfls[1]->getIJ(0,0));
1362   CPPUNIT_ASSERT_EQUAL(1,(int)pfls[1]->getIJ(1,0));
1363   pfls[0]->decrRef();
1364   pfls[1]->decrRef();
1365   d->decrRef();
1366   idsInPflPerType.clear();
1367   pfls.clear();
1368   code.clear();
1369   //
1370   const mcIdType val2[4]={0,2,3,4};// all quad4 are selected here ! So no profile for Quads
1371   d=DataArrayIdType::New();
1372   d->alloc(4,1);
1373   std::copy(val2,val2+4,d->getPointer());
1374   m->splitProfilePerType(d,code,idsInPflPerType,pfls);
1375   CPPUNIT_ASSERT_EQUAL(6,(int)code.size());
1376   CPPUNIT_ASSERT_EQUAL(2,(int)idsInPflPerType.size());
1377   const mcIdType expected2[6]={3,1,0, 4,3,-1};
1378   for(int i=0;i<6;i++)
1379     CPPUNIT_ASSERT_EQUAL(expected2[i],code[i]);
1380   CPPUNIT_ASSERT_EQUAL(1,(int)idsInPflPerType[0]->getNumberOfTuples());
1381   CPPUNIT_ASSERT_EQUAL(0,(int)idsInPflPerType[0]->getIJ(0,0));
1382   CPPUNIT_ASSERT_EQUAL(3,(int)idsInPflPerType[1]->getNumberOfTuples());
1383   CPPUNIT_ASSERT_EQUAL(1,(int)idsInPflPerType[1]->getIJ(0,0));
1384   CPPUNIT_ASSERT_EQUAL(2,(int)idsInPflPerType[1]->getIJ(1,0));
1385   CPPUNIT_ASSERT_EQUAL(3,(int)idsInPflPerType[1]->getIJ(2,0));
1386   idsInPflPerType[0]->decrRef();
1387   idsInPflPerType[1]->decrRef();
1388   CPPUNIT_ASSERT_EQUAL(1,(int)pfls.size());
1389   CPPUNIT_ASSERT_EQUAL(1,(int)pfls[0]->getNumberOfTuples());
1390   CPPUNIT_ASSERT_EQUAL(0,(int)pfls[0]->getIJ(0,0));
1391   pfls[0]->decrRef();
1392   d->decrRef();
1393   idsInPflPerType.clear();
1394   pfls.clear();
1395   code.clear();
1396   //
1397   const mcIdType val3[3]={1,0,2};// all tri3 are selected here but not in the same order ! Profile requested for Tri3
1398   d=DataArrayIdType::New();
1399   d->alloc(3,1);
1400   std::copy(val3,val3+3,d->getPointer());
1401   m->splitProfilePerType(d,code,idsInPflPerType,pfls);
1402   CPPUNIT_ASSERT_EQUAL(6,(int)code.size());
1403   CPPUNIT_ASSERT_EQUAL(2,(int)idsInPflPerType.size());
1404   const mcIdType expected3[6]={3,2,0, 4,1,1};
1405   for(int i=0;i<6;i++)
1406     CPPUNIT_ASSERT_EQUAL(expected3[i],code[i]);
1407   CPPUNIT_ASSERT_EQUAL(2,(int)idsInPflPerType[0]->getNumberOfTuples());
1408   CPPUNIT_ASSERT_EQUAL(0,(int)idsInPflPerType[0]->getIJ(0,0));
1409   CPPUNIT_ASSERT_EQUAL(1,(int)idsInPflPerType[0]->getIJ(1,0));
1410   CPPUNIT_ASSERT_EQUAL(1,(int)idsInPflPerType[1]->getNumberOfTuples());
1411   CPPUNIT_ASSERT_EQUAL(2,(int)idsInPflPerType[1]->getIJ(0,0));
1412   idsInPflPerType[0]->decrRef();
1413   idsInPflPerType[1]->decrRef();
1414   CPPUNIT_ASSERT_EQUAL(2,(int)pfls.size());
1415   CPPUNIT_ASSERT_EQUAL(2,(int)pfls[0]->getNumberOfTuples());
1416   CPPUNIT_ASSERT_EQUAL(1,(int)pfls[0]->getIJ(0,0));
1417   CPPUNIT_ASSERT_EQUAL(0,(int)pfls[0]->getIJ(1,0));
1418   CPPUNIT_ASSERT_EQUAL(0,(int)pfls[1]->getIJ(0,0));
1419   pfls[0]->decrRef();
1420   pfls[1]->decrRef();
1421   d->decrRef();
1422   idsInPflPerType.clear();
1423   pfls.clear();
1424   code.clear();
1425   //
1426   const mcIdType val4[2]={3,4};// all tri3 are selected here but not in the same order ! Profile requested for Tri3
1427   d=DataArrayIdType::New();
1428   d->alloc(2,1);
1429   std::copy(val4,val4+2,d->getPointer());
1430   m->splitProfilePerType(d,code,idsInPflPerType,pfls);
1431   CPPUNIT_ASSERT_EQUAL(3,(int)code.size());
1432   CPPUNIT_ASSERT_EQUAL(1,(int)idsInPflPerType.size());
1433   const mcIdType expected4[3]={4,2,0};
1434   for(int i=0;i<3;i++)
1435     CPPUNIT_ASSERT_EQUAL(expected4[i],code[i]);
1436   CPPUNIT_ASSERT_EQUAL(2,(int)idsInPflPerType[0]->getNumberOfTuples());
1437   CPPUNIT_ASSERT_EQUAL(0,(int)idsInPflPerType[0]->getIJ(0,0));
1438   CPPUNIT_ASSERT_EQUAL(1,(int)idsInPflPerType[0]->getIJ(1,0));
1439   idsInPflPerType[0]->decrRef();
1440   CPPUNIT_ASSERT_EQUAL(1,(int)pfls.size());
1441   CPPUNIT_ASSERT_EQUAL(2,(int)pfls[0]->getNumberOfTuples());
1442   CPPUNIT_ASSERT_EQUAL(1,(int)pfls[0]->getIJ(0,0));
1443   CPPUNIT_ASSERT_EQUAL(2,(int)pfls[0]->getIJ(1,0));
1444   pfls[0]->decrRef();
1445   d->decrRef();
1446   idsInPflPerType.clear();
1447   pfls.clear();
1448   code.clear();
1449   //
1450   m->decrRef();
1451 }
1452
1453 void MEDCouplingBasicsTest4::testDAIBuildExplicitArrByRanges1()
1454 {
1455   DataArrayIdType *d=DataArrayIdType::New();
1456   d->alloc(3,1);
1457   const mcIdType vals1[3]={0,2,3};
1458   std::copy(vals1,vals1+3,d->getPointer());
1459   DataArrayIdType *e=DataArrayIdType::New();
1460   e->alloc(6,1);
1461   const mcIdType vals2[6]={0,3,6,10,14,20};
1462   std::copy(vals2,vals2+6,e->getPointer());
1463   //
1464   DataArrayIdType *f=d->buildExplicitArrByRanges(e);
1465   CPPUNIT_ASSERT_EQUAL(11,(int)f->getNumberOfTuples());
1466   CPPUNIT_ASSERT_EQUAL(1,(int)f->getNumberOfComponents());
1467   const mcIdType expected1[11]={0,1,2,6,7,8,9,10,11,12,13};
1468   for(int i=0;i<11;i++)
1469     CPPUNIT_ASSERT_EQUAL(expected1[i],f->getIJ(i,0));
1470   //
1471   f->decrRef();
1472   e->decrRef();
1473   d->decrRef();
1474 }
1475
1476 void MEDCouplingBasicsTest4::testDAIComputeOffsets2()
1477 {
1478   DataArrayIdType *d=DataArrayIdType::New();
1479   const mcIdType vals1[6]={3,5,1,2,0,8};
1480   const mcIdType expected1[7]={0,3,8,9,11,11,19};
1481   d->alloc(6,1);
1482   std::copy(vals1,vals1+6,d->getPointer());
1483   d->computeOffsetsFull();
1484   CPPUNIT_ASSERT_EQUAL(7,(int)d->getNumberOfTuples());
1485   CPPUNIT_ASSERT_EQUAL(1,(int)d->getNumberOfComponents());
1486   for(int i=0;i<7;i++)
1487     CPPUNIT_ASSERT_EQUAL(expected1[i],d->getIJ(0,i));
1488   d->decrRef();
1489 }
1490
1491 void MEDCouplingBasicsTest4::testMergeField3()
1492 {
1493   MEDCouplingUMesh *m=build2DTargetMesh_1();
1494   m->getCoords()->setInfoOnComponent(0,"x [m]");
1495   m->getCoords()->setInfoOnComponent(1,"z [km]");
1496   m->setName("m");
1497   m->setDescription("desc");
1498   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
1499   f1->setName("f1");
1500   f1->setMesh(m);
1501   DataArrayDouble *arr=DataArrayDouble::New();
1502   arr->alloc(5,2);
1503   arr->setInfoOnComponent(0,"X [m]");
1504   arr->setInfoOnComponent(1,"YY [mm]");
1505   arr->fillWithValue(2.);
1506   f1->setArray(arr);
1507   arr->decrRef();
1508   m->decrRef();
1509   //
1510   std::vector<const MEDCouplingFieldDouble *> tmp(1);
1511   tmp[0]=f1;
1512   MEDCouplingFieldDouble *f2=MEDCouplingFieldDouble::MergeFields(tmp);
1513   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
1514   //
1515   f1->decrRef();
1516   f2->decrRef();
1517 }
1518
1519 void MEDCouplingBasicsTest4::testGetDistributionOfTypes1()
1520 {
1521   MEDCouplingUMesh *m=build2DTargetMesh_1();
1522   const mcIdType tab1[5]={2,0,1,3,4};
1523   CPPUNIT_ASSERT_THROW(m->getDistributionOfTypes(),INTERP_KERNEL::Exception);
1524   m->renumberCells(tab1,false);
1525   std::vector<mcIdType> code=m->getDistributionOfTypes();
1526   CPPUNIT_ASSERT_EQUAL(6,(int)code.size());
1527   CPPUNIT_ASSERT_EQUAL(3,(int)code[0]);
1528   CPPUNIT_ASSERT_EQUAL(2,(int)code[1]);
1529   CPPUNIT_ASSERT_EQUAL(-1,(int)code[2]);
1530   CPPUNIT_ASSERT_EQUAL(4,(int)code[3]);
1531   CPPUNIT_ASSERT_EQUAL(3,(int)code[4]);
1532   CPPUNIT_ASSERT_EQUAL(-1,(int)code[5]);
1533   m->decrRef();
1534 }
1535
1536 void MEDCouplingBasicsTest4::testNorm2_1()
1537 {
1538   MEDCouplingUMesh *m=build2DTargetMesh_1();
1539   MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
1540   f->setMesh(m);
1541   m->decrRef();
1542   //
1543   DataArrayDouble *d=DataArrayDouble::New();
1544   const double tab[10]={1.2,1.3,2.2,2.3,3.2,3.3,4.2,4.3,5.2,5.3};
1545   d->alloc(5,2);
1546   std::copy(tab,tab+10,d->getPointer());
1547   f->setArray(d);
1548   d->decrRef();
1549   f->checkConsistencyLight();
1550   //
1551   CPPUNIT_ASSERT_DOUBLES_EQUAL(11.209371079592289,f->norm2(),1e-14);
1552   //
1553   f->decrRef();
1554 }
1555
1556 void MEDCouplingBasicsTest4::testNormMax1()
1557 {
1558   MEDCouplingUMesh *m=build2DTargetMesh_1();
1559   MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
1560   f->setMesh(m);
1561   m->decrRef();
1562   //
1563   DataArrayDouble *d=DataArrayDouble::New(); d->alloc(0,2);
1564   double res[2];
1565   d->normMaxPerComponent(res);
1566
1567   CPPUNIT_ASSERT_DOUBLES_EQUAL(-1.0,res[0],1e-14);
1568   CPPUNIT_ASSERT_DOUBLES_EQUAL(-1.0,res[1],1e-14);
1569
1570   const double tab[10]={2.3,-1.2,6.3,-7.8,2.9,7.7,2.1,0.,3.6,-7.6};
1571   d->alloc(5,2);
1572   std::copy(tab,tab+10,d->getPointer());
1573
1574   d->normMaxPerComponent(res);
1575   CPPUNIT_ASSERT_DOUBLES_EQUAL(6.3,res[0],1e-14);
1576   CPPUNIT_ASSERT_DOUBLES_EQUAL(7.8,res[1],1e-14);
1577
1578   f->setArray(d);
1579   d->decrRef();
1580   f->checkConsistencyLight();
1581   //
1582   f->normMax(res);
1583   CPPUNIT_ASSERT_DOUBLES_EQUAL(6.3,res[0],1e-14);
1584   CPPUNIT_ASSERT_DOUBLES_EQUAL(7.8,res[1],1e-14);
1585   //
1586   CPPUNIT_ASSERT_DOUBLES_EQUAL(6.3,f->normMax(0),1e-14);
1587   CPPUNIT_ASSERT_DOUBLES_EQUAL(7.8,f->normMax(1),1e-14);
1588   f->decrRef();
1589 }
1590
1591 void MEDCouplingBasicsTest4::testFindAndCorrectBadOriented3DExtrudedCells1()
1592 {
1593   const double coords[38*3]={0.0011180339887498999, -0.0011755705045849499, 0.0, -0.0012331070204200001, -0.0011755705045849499, 0.0, -0.00067557050458494599, -0.00145964954842536, 0.0, -0.00050000000000000001, -0.00086602540378443902, 0.0, 0.00140211303259031, -0.00061803398874989504, 0.0, 0.00086602540378443902, -0.00050000000000000001, 0.0, 0.001, 0.0, 0.0, 0.00034561537182258202, 0.000269164072574575, 0.0, 0.0, 0.001, 0.0, -0.00050000000000000001, 0.00086602540378443902, 0.0, -0.000269164072574575, 0.00034561537182258202, 0.0, -0.001, 0.0, 0.0, -0.00086602540378443902, -0.00050000000000000001, 0.0, -0.00034561537182258202, -0.000269164072574575, 0.0, 0.0, -0.001, 0.0, 0.00050000000000000001, -0.00086602540378443902, 0.0, 0.000269164072574575, -0.00034561537182258202, 0.0, 0.0015, -6.01853107621011e-36, 0.0, 0.00056049747291484397, -0.00145964954842536, 0.0, 0.0011180339887498999, -0.0011755705045849499, 0.00050000000000000001, -0.0012331070204200001, -0.0011755705045849499, 0.00050000000000000001, -0.00067557050458494599, -0.00145964954842536, 0.00050000000000000001, -0.00050000000000000001, -0.00086602540378443902, 0.00050000000000000001, 0.00140211303259031, -0.00061803398874989504, 0.00050000000000000001, 0.00086602540378443902, -0.00050000000000000001, 0.00050000000000000001, 0.001, 0.0, 0.00050000000000000001, 0.00034561537182258202, 0.000269164072574575, 0.00050000000000000001, 0.0, 0.001, 0.00050000000000000001, -0.00050000000000000001, 0.00086602540378443902, 0.00050000000000000001, -0.000269164072574575, 0.00034561537182258202, 0.00050000000000000001, -0.001, 0.0, 0.00050000000000000001, -0.00086602540378443902, -0.00050000000000000001, 0.00050000000000000001, -0.00034561537182258202, -0.000269164072574575, 0.00050000000000000001, 0.0, -0.001, 0.00050000000000000001, 0.00050000000000000001, -0.00086602540378443902, 0.00050000000000000001, 0.000269164072574575, -0.00034561537182258202, 0.00050000000000000001, 0.0015, -6.01853107621011e-36, 0.00050000000000000001, 0.00056049747291484397, -0.00145964954842536, 0.00050000000000000001};
1594   const mcIdType conn[56]={2, 1, 3, 21, 20, 22, 4, 0, 5, 23, 19, 24, 8, 9, 10, 27, 28, 29, 11, 12, 13, 30, 31, 32, 0, 18, 15, 5, 19, 37, 34, 24, 6, 17, 4, 5, 25, 36, 23, 24, 3, 14, 16, 13, 22, 33, 35, 32, 13, 16, 7, 10, 32, 35, 26, 29};
1595   const mcIdType connExp[64]={16, 2, 1, 3, 21, 20, 22, 16, 4, 0, 5, 23, 19, 24, 16, 8, 10, 9, 27, 29, 28, 16, 11, 13, 12, 30, 32, 31, 18, 0, 18, 15, 5, 19, 37, 34, 24,18, 6, 17, 4, 5, 25, 36, 23, 24, 18, 3, 13, 16, 14, 22, 32, 35, 33, 18, 13, 10, 7, 16, 32, 29, 26, 35};
1596   const mcIdType invalidCells[4]={2,3,6,7};
1597   MEDCouplingUMesh *m=MEDCouplingUMesh::New("Example",3);
1598   DataArrayDouble *coo=DataArrayDouble::New();
1599   coo->alloc(38,3);
1600   std::copy(coords,coords+114,coo->getPointer());
1601   m->setCoords(coo);
1602   coo->decrRef();
1603   m->allocateCells(8);
1604   m->insertNextCell(INTERP_KERNEL::NORM_PENTA6,6,conn);
1605   m->insertNextCell(INTERP_KERNEL::NORM_PENTA6,6,conn+6);
1606   m->insertNextCell(INTERP_KERNEL::NORM_PENTA6,6,conn+12);
1607   m->insertNextCell(INTERP_KERNEL::NORM_PENTA6,6,conn+18);
1608   m->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+24);
1609   m->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+32);
1610   m->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+40);
1611   m->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+48);
1612   m->finishInsertingCells();
1613   //
1614   DataArrayIdType *v=m->findAndCorrectBadOriented3DExtrudedCells();
1615  CPPUNIT_ASSERT_EQUAL(4,(int)v->getNumberOfTuples());
1616   CPPUNIT_ASSERT(std::equal(v->begin(),v->end(),invalidCells));
1617   CPPUNIT_ASSERT(std::equal(connExp,connExp+64,m->getNodalConnectivity()->getConstPointer()));
1618   v->decrRef();
1619   //
1620   m->decrRef();
1621 }
1622
1623 void MEDCouplingBasicsTest4::testConvertExtrudedPolyhedra1()
1624 {
1625   const mcIdType conn[72]={1,2,3,4, 5,6,7,8,9,10,11,12, 13,14,15,16, 17,18,19,20,21,22, 23,24,25,26,27,28, 29,30,31,32,33,34,35,36,37,38, 39,40,41,42,43,44,45,46, 47,48,49,50,51,52,53,54,55,56,57,58, 59,60,61,62,63,64,65,66,67,68,69,70,71,72};
1626   MEDCouplingUMesh *m=MEDCouplingUMesh::New("Example",3);
1627   DataArrayDouble *coo=DataArrayDouble::New();
1628   coo->alloc(73,3);
1629   coo->rearrange(1); coo->iota(0); coo->rearrange(3);
1630   m->setCoords(coo);
1631   coo->decrRef();
1632   m->allocateCells(9);
1633   m->insertNextCell(INTERP_KERNEL::NORM_TETRA4,4,conn);
1634   m->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+4);
1635   m->insertNextCell(INTERP_KERNEL::NORM_TETRA4,4,conn+12);
1636   m->insertNextCell(INTERP_KERNEL::NORM_POLYHED,6,conn+16);
1637   m->insertNextCell(INTERP_KERNEL::NORM_PENTA6,6,conn+22);
1638   m->insertNextCell(INTERP_KERNEL::NORM_POLYHED,10,conn+28);
1639   m->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+38);
1640   m->insertNextCell(INTERP_KERNEL::NORM_HEXGP12,12,conn+46);
1641   m->insertNextCell(INTERP_KERNEL::NORM_POLYHED,14,conn+58);
1642   m->finishInsertingCells();
1643   //
1644   m->convertExtrudedPolyhedra();
1645   DataArrayIdType *da=m->getNodalConnectivity();
1646   DataArrayIdType *dai=m->getNodalConnectivityIndex();
1647   CPPUNIT_ASSERT_EQUAL(ToIdType(10),dai->getNbOfElems());
1648   CPPUNIT_ASSERT_EQUAL(ToIdType(159),da->getNbOfElems());
1649   //
1650   const mcIdType expected1[159]={14,1,2,3,4,
1651                             18,5,6,7,8,9,10,11,12,
1652                             14,13,14,15,16,
1653                             31,17,18,19,-1,20,22,21,-1,17,20,21,18,-1,18,21,22,19,-1,19,22,20,17,
1654                             16,23,24,25,26,27,28,
1655                             31,29,30,31,32,33,-1,34,38,37,36,35,-1,29,34,35,30,-1,30,35,36,31,-1,31,36,37,32,-1,32,37,38,33,-1,33,38,34,29,
1656                             18,39,40,41,42,43,44,45,46,
1657                             22,47,48,49,50,51,52,53,54,55,56,57,58,
1658                             31,59,60,61,62,63,64,65,-1,66,72,71,70,69,68,67,-1,59,66,67,60,-1,60,67,68,61,-1,61,68,69,62,-1,62,69,70,63,-1,63,70,71,64,-1,64,71,72,65,-1,65,72,66,59};
1659   const mcIdType expected2[10]={0,5,14,19,42,49,86,95,108,159};
1660   CPPUNIT_ASSERT(std::equal(expected1,expected1+159,da->getConstPointer()));
1661   CPPUNIT_ASSERT(std::equal(expected2,expected2+10,dai->getConstPointer()));
1662   m->checkConsistency();
1663   //
1664   m->decrRef();
1665 }
1666
1667 void MEDCouplingBasicsTest4::testNonRegressionCopyTinyStrings()
1668 {
1669   MEDCouplingUMesh *m=build2DTargetMesh_1();
1670   MEDCouplingFieldDouble *f1=m->getMeasureField(true);
1671   f1->getArray()->setInfoOnComponent(0,"P [N/m^2]");
1672   DataArrayDouble *bary=m->computeCellCenterOfMass();
1673   MEDCouplingFieldDouble *f2=f1->buildNewTimeReprFromThis(NO_TIME,false);
1674   f2->setArray(bary);
1675   CPPUNIT_ASSERT_THROW(f1->copyTinyAttrFrom(f2),INTERP_KERNEL::Exception);
1676   m->decrRef();
1677   f1->decrRef();
1678   bary->decrRef();
1679   f2->decrRef();
1680 }
1681
1682 void MEDCouplingBasicsTest4::testDaDSetPartOfValuesAdv1()
1683 {
1684   const double tab1[18]={3.,4.,5., 13.,14.,15., 23.,24.,25., 33.,34.,35., 43.,44.,45., 53.,54.,55.};
1685   const double tab2[9]={6.,7.,8., 16.,17.,18., 26.,27.,28.};
1686   const mcIdType tab3[6]={4,1, 2,2, 3,0};
1687   DataArrayDouble *a=DataArrayDouble::New();
1688   a->alloc(6,3);
1689   std::copy(tab1,tab1+18,a->getPointer());
1690   DataArrayDouble *b=DataArrayDouble::New();
1691   b->alloc(3,3);
1692   std::copy(tab2,tab2+9,b->getPointer());
1693   DataArrayIdType *c=DataArrayIdType::New();
1694   c->alloc(3,2);
1695   std::copy(tab3,tab3+6,c->getPointer());
1696   //
1697   a->setPartOfValuesAdv(b,c);
1698   const double expected1[18]={3.,4.,5., 13.,14.,15., 26.,27.,28., 6.,7.,8., 16.,17.,18., 53.,54.,55.};
1699   std::equal(expected1,expected1+18,a->getConstPointer());
1700   //
1701   a->decrRef();
1702   b->decrRef();
1703   c->decrRef();
1704 }
1705
1706 void MEDCouplingBasicsTest4::testUMeshBuildSetInstanceFromThis1()
1707 {
1708   MEDCouplingUMesh *m=build3DSurfTargetMesh_1();
1709   MEDCouplingUMesh *m2=m->buildSetInstanceFromThis(3);
1710   CPPUNIT_ASSERT_EQUAL(m->getNodalConnectivity(),m2->getNodalConnectivity());
1711   CPPUNIT_ASSERT_EQUAL(m->getNodalConnectivityIndex(),m2->getNodalConnectivityIndex());
1712   CPPUNIT_ASSERT_EQUAL(m->getCoords(),m2->getCoords());
1713   m2->decrRef();
1714   m->decrRef();
1715   //
1716   m=MEDCouplingUMesh::New("toto",2);
1717   m2=m->buildSetInstanceFromThis(3);
1718   CPPUNIT_ASSERT_EQUAL(0,(int)m2->getNumberOfNodes());
1719   CPPUNIT_ASSERT_EQUAL(0,(int)m2->getNumberOfCells());
1720   m->decrRef();
1721   m2->decrRef();
1722 }
1723
1724 void MEDCouplingBasicsTest4::testUMeshMergeMeshesCVW1()
1725 {
1726   MEDCouplingUMesh *m=build3DSurfTargetMesh_1();
1727   MEDCouplingUMesh *m2=MEDCouplingUMesh::New("toto",2);
1728   MEDCouplingUMesh *m3=MEDCouplingUMesh::MergeUMeshes(m,m2);
1729   m3->setName(m->getName().c_str());
1730   CPPUNIT_ASSERT(m->isEqual(m3,1e-12));
1731   m3->decrRef();
1732   m->decrRef();
1733   m2->decrRef();
1734 }
1735
1736 void MEDCouplingBasicsTest4::testChangeUnderlyingMeshWithCMesh1()
1737 {
1738   MEDCouplingCMesh* mesh=MEDCouplingCMesh::New();
1739   DataArrayDouble* coordsX=DataArrayDouble::New();
1740   double arrX[4] = { -1., 1., 2., 4. };
1741   coordsX->useArray(arrX,false, DeallocType::CPP_DEALLOC,4,1);
1742   DataArrayDouble* coordsY=DataArrayDouble::New();
1743   double arrY[4] = { -2., 2., 4., 8. };
1744   coordsY->useArray(arrY,false, DeallocType::CPP_DEALLOC,4,1);
1745   DataArrayDouble* coordsZ=DataArrayDouble::New();
1746   double arrZ[4] = { -3., 3., 6., 12. };
1747   coordsZ->useArray(arrZ,false, DeallocType::CPP_DEALLOC,4,1);
1748   mesh->setCoords(coordsX,coordsY,coordsZ);
1749   coordsX->decrRef();
1750   coordsY->decrRef();
1751   coordsZ->decrRef();
1752   MEDCouplingMesh *mesh2=mesh->deepCopy();
1753   //
1754   static const mcIdType ids1[9]={0,1,2,10,11,12,20,21,22};
1755   for(const mcIdType *myId=ids1;myId!=ids1+9;myId++)
1756     {
1757       MEDCouplingFieldDouble *f=mesh->getMeasureField(true);
1758       f->changeUnderlyingMesh(mesh2,*myId,1e-12);
1759       f->decrRef();
1760     }
1761   mesh2->setName("uuuu");
1762   for(const mcIdType *myId=ids1+1;myId!=ids1+9;myId++)
1763     {
1764       MEDCouplingFieldDouble *f=mesh->getMeasureField(true);
1765       f->changeUnderlyingMesh(mesh2,*myId,1e-12);
1766       f->decrRef();
1767     }
1768   //
1769   mesh2->decrRef();
1770   mesh->decrRef();
1771 }
1772
1773 void MEDCouplingBasicsTest4::testDADFindCommonTuples1()
1774 {
1775   DataArrayDouble *da=DataArrayDouble::New();
1776   da->alloc(6,1);
1777   const double array1[6]={2.3,1.2,1.3,2.3,2.301,0.8};
1778   std::copy(array1,array1+6,da->getPointer());
1779   DataArrayIdType *c=0,*cI=0;
1780   // nbOftuples=1
1781   da->findCommonTuples(1e-2,-1,c,cI);
1782   const mcIdType expected1[3]={0,3,4};
1783   const mcIdType expected2[2]={0,3};
1784   CPPUNIT_ASSERT_EQUAL(ToIdType(3),c->getNbOfElems());
1785   CPPUNIT_ASSERT_EQUAL(ToIdType(2),cI->getNbOfElems());
1786   CPPUNIT_ASSERT(std::equal(expected1,expected1+3,c->getConstPointer()));
1787   CPPUNIT_ASSERT(std::equal(expected2,expected2+2,cI->getConstPointer()));
1788   c->decrRef();
1789   cI->decrRef();
1790   //
1791   da->findCommonTuples(2e-1,-1,c,cI);
1792   const mcIdType expected3[5]={0,3,4,1,2};
1793   const mcIdType expected4[3]={0,3,5};
1794   CPPUNIT_ASSERT_EQUAL(ToIdType(5),c->getNbOfElems());
1795   CPPUNIT_ASSERT_EQUAL(ToIdType(3),cI->getNbOfElems());
1796   CPPUNIT_ASSERT(std::equal(expected3,expected3+5,c->getConstPointer()));
1797   CPPUNIT_ASSERT(std::equal(expected4,expected4+3,cI->getConstPointer()));
1798   c->decrRef();
1799   cI->decrRef();
1800   // nbOftuples=2
1801   da->alloc(6,2);
1802   const double array2[12]={2.3,2.3,1.2,1.2,1.3,1.3,2.3,2.3,2.301,2.301,0.8,0.8};
1803   std::copy(array2,array2+12,da->getPointer());
1804   da->findCommonTuples(1e-2,-1,c,cI);
1805   CPPUNIT_ASSERT_EQUAL(ToIdType(3),c->getNbOfElems());
1806   CPPUNIT_ASSERT_EQUAL(ToIdType(2),cI->getNbOfElems());
1807   CPPUNIT_ASSERT(std::equal(expected1,expected1+3,c->getConstPointer()));
1808   CPPUNIT_ASSERT(std::equal(expected2,expected2+2,cI->getConstPointer()));
1809   c->decrRef();
1810   cI->decrRef();
1811   //
1812   da->findCommonTuples(2e-1,-1,c,cI);
1813   CPPUNIT_ASSERT_EQUAL(ToIdType(5),c->getNbOfElems());
1814   CPPUNIT_ASSERT_EQUAL(ToIdType(3),cI->getNbOfElems());
1815   CPPUNIT_ASSERT(std::equal(expected3,expected3+5,c->getConstPointer()));
1816   CPPUNIT_ASSERT(std::equal(expected4,expected4+3,cI->getConstPointer()));
1817   c->decrRef();
1818   cI->decrRef();
1819   // nbOftuples=3
1820   da->alloc(6,3);
1821   const double array3[18]={2.3,2.3,2.3,1.2,1.2,1.2,1.3,1.3,1.3,2.3,2.3,2.3,2.301,2.301,2.301,0.8,0.8,0.8};
1822   std::copy(array3,array3+18,da->getPointer());
1823   da->findCommonTuples(1e-2,-1,c,cI);
1824   CPPUNIT_ASSERT_EQUAL(ToIdType(3),c->getNbOfElems());
1825   CPPUNIT_ASSERT_EQUAL(ToIdType(2),cI->getNbOfElems());
1826   CPPUNIT_ASSERT(std::equal(expected1,expected1+3,c->getConstPointer()));
1827   CPPUNIT_ASSERT(std::equal(expected2,expected2+2,cI->getConstPointer()));
1828   c->decrRef();
1829   cI->decrRef();
1830   //
1831   da->findCommonTuples(2e-1,-1,c,cI);
1832   CPPUNIT_ASSERT_EQUAL(ToIdType(5),c->getNbOfElems());
1833   CPPUNIT_ASSERT_EQUAL(ToIdType(3),cI->getNbOfElems());
1834   CPPUNIT_ASSERT(std::equal(expected3,expected3+5,c->getConstPointer()));
1835   CPPUNIT_ASSERT(std::equal(expected4,expected4+3,cI->getConstPointer()));
1836   c->decrRef();
1837   cI->decrRef();
1838   //
1839   const double array11[6]={2.3,1.2,1.3,2.4,2.5,0.8};
1840   da->alloc(6,1);
1841   std::copy(array11,array11+6,da->getPointer());
1842   // nbOftuples=1, no common groups
1843   da->findCommonTuples(1e-2,-1,c,cI);
1844   CPPUNIT_ASSERT_EQUAL(ToIdType(0),c->getNbOfElems());
1845   CPPUNIT_ASSERT_EQUAL(ToIdType(1),cI->getNbOfElems());
1846   CPPUNIT_ASSERT_EQUAL(ToIdType(0),cI->getIJ(0,0));
1847
1848   da->alloc(6,5);  //bad NumberOfComponents
1849   CPPUNIT_ASSERT_THROW(da->findCommonTuples(1e-2,-1,c,cI),INTERP_KERNEL::Exception);
1850
1851   c->decrRef();
1852   cI->decrRef();
1853   da->decrRef();
1854 }
1855
1856 void MEDCouplingBasicsTest4::testDABack1()
1857 {
1858   DataArrayDouble *da=DataArrayDouble::New();
1859   da->alloc(6,1);
1860   const double array1[6]={2.3,1.2,1.3,2.3,2.301,0.8};
1861   std::copy(array1,array1+6,da->getPointer());
1862   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.8,da->back(),1e-14);
1863   da->rearrange(2);
1864   CPPUNIT_ASSERT_THROW(da->back(),INTERP_KERNEL::Exception);
1865   da->alloc(0,1);
1866   CPPUNIT_ASSERT_THROW(da->back(),INTERP_KERNEL::Exception);
1867   da->decrRef();
1868   //
1869   DataArrayIdType *da2=DataArrayIdType::New();
1870   da2->alloc(4,1);
1871   const mcIdType array2[4]={4,7,8,2};
1872   std::copy(array2,array2+4,da2->getPointer());
1873   CPPUNIT_ASSERT_EQUAL(ToIdType(2),da2->back());
1874   da2->rearrange(2);
1875   CPPUNIT_ASSERT_THROW(da2->back(),INTERP_KERNEL::Exception);
1876   da2->alloc(0,1);
1877   CPPUNIT_ASSERT_THROW(da2->back(),INTERP_KERNEL::Exception);
1878   da2->decrRef();
1879 }
1880
1881 void MEDCouplingBasicsTest4::testDADGetDifferentValues1()
1882 {
1883   DataArrayDouble *da=DataArrayDouble::New();
1884   da->alloc(6,1);
1885   const double array1[6]={2.3,1.2,1.3,2.3,2.301,0.8};
1886   std::copy(array1,array1+6,da->getPointer());
1887   //
1888   const double expected1[4]={2.301,1.2,1.3,0.8};
1889   DataArrayDouble *dv=da->getDifferentValues(1e-2);
1890   CPPUNIT_ASSERT_EQUAL(ToIdType(4),dv->getNbOfElems());
1891   for(int i=0;i<4;i++)
1892     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],dv->getIJ(i,0),1e-14);
1893   dv->decrRef();
1894   //
1895   dv=da->getDifferentValues(2e-1);
1896   const double expected2[3]={2.301,1.3,0.8};
1897   CPPUNIT_ASSERT_EQUAL(ToIdType(3),dv->getNbOfElems());
1898   for(int i=0;i<3;i++)
1899     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],dv->getIJ(i,0),1e-14);
1900   dv->decrRef();
1901   da->decrRef();
1902 }
1903
1904 void MEDCouplingBasicsTest4::testDAIBuildOld2NewArrayFromSurjectiveFormat2()
1905 {
1906   const mcIdType arr[5]={0,3, 5,7,9};
1907   const mcIdType arrI[3]={0,2,5};
1908   DataArrayIdType *a=DataArrayIdType::New();
1909   a->alloc(5,1);
1910   std::copy(arr,arr+5,a->getPointer());
1911   DataArrayIdType *b=DataArrayIdType::New();
1912   b->alloc(3,1);
1913   std::copy(arrI,arrI+3,b->getPointer());
1914   mcIdType newNbTuple=-1;
1915   DataArrayIdType *ret=DataArrayIdType::ConvertIndexArrayToO2N(10,a->begin(),b->begin(),b->end(),newNbTuple);
1916   const mcIdType expected[10]={0,1,2,0,3,4,5,4,6,4};
1917   CPPUNIT_ASSERT_EQUAL(ToIdType(10),ret->getNbOfElems());
1918   CPPUNIT_ASSERT_EQUAL(ToIdType(7),newNbTuple);
1919   CPPUNIT_ASSERT_EQUAL(1,(int)ret->getNumberOfComponents());
1920   CPPUNIT_ASSERT(std::equal(expected,expected+10,ret->getConstPointer()));
1921   CPPUNIT_ASSERT_THROW(DataArrayIdType::ConvertIndexArrayToO2N(9,a->begin(),b->begin(),b->end(),newNbTuple),INTERP_KERNEL::Exception);
1922   ret->decrRef();
1923   b->decrRef();
1924   a->decrRef();
1925 }
1926
1927 void MEDCouplingBasicsTest4::testDADIReverse1()
1928 {
1929   const mcIdType arr[6]={0,3,5,7,9,2};
1930   DataArrayIdType *a=DataArrayIdType::New();
1931   a->alloc(6,1);
1932   std::copy(arr,arr+6,a->getPointer());
1933   CPPUNIT_ASSERT_EQUAL(ToIdType(2),a->back());
1934   a->reverse();
1935   for(int i=0;i<6;i++)
1936     CPPUNIT_ASSERT_EQUAL(arr[5-i],a->getIJ(i,0));
1937   a->alloc(5,1);
1938   std::copy(arr,arr+5,a->getPointer());
1939   a->reverse();
1940   for(int i=0;i<5;i++)
1941     CPPUNIT_ASSERT_EQUAL(arr[4-i],a->getIJ(i,0));
1942   a->decrRef();
1943   //
1944   const double arr2[6]={0.,3.,5.,7.,9.,2.};
1945    DataArrayDouble *b=DataArrayDouble::New();
1946    b->alloc(6,1);
1947    std::copy(arr2,arr2+6,b->getPointer());
1948    b->reverse();
1949    for(int i=0;i<6;i++)
1950      CPPUNIT_ASSERT_DOUBLES_EQUAL(arr2[5-i],b->getIJ(i,0),1e-14);
1951    b->alloc(5,1);
1952    std::copy(arr,arr+5,b->getPointer());
1953    CPPUNIT_ASSERT_DOUBLES_EQUAL(9.,b->back(),1e-14);
1954    b->reverse();
1955    for(int i=0;i<5;i++)
1956      CPPUNIT_ASSERT_DOUBLES_EQUAL(arr2[4-i],b->getIJ(i,0),1e-14);
1957    b->decrRef();
1958 }
1959
1960 void MEDCouplingBasicsTest4::testGetNodeIdsInUse1()
1961 {
1962   MEDCouplingUMesh *m0=build2DTargetMesh_1();
1963   const mcIdType CellIds[2]={1,2};
1964   MEDCouplingUMesh *m1=static_cast<MEDCouplingUMesh *>(m0->buildPartOfMySelf(CellIds,CellIds+2,true));
1965   mcIdType newNbOfNodes=-1;
1966   DataArrayIdType *arr=m1->getNodeIdsInUse(newNbOfNodes);
1967   const mcIdType expected[9]={-1,0,1,-1,2,3,-1,-1,-1};
1968   CPPUNIT_ASSERT_EQUAL(ToIdType(4),newNbOfNodes);
1969   CPPUNIT_ASSERT_EQUAL(ToIdType(9),arr->getNbOfElems());
1970   CPPUNIT_ASSERT(std::equal(expected,expected+9,arr->getConstPointer()));
1971   DataArrayIdType *arr2=arr->invertArrayO2N2N2O(newNbOfNodes);
1972   CPPUNIT_ASSERT_EQUAL(ToIdType(4),arr2->getNbOfElems());
1973   const mcIdType expected2[4]={1,2,4,5};
1974   CPPUNIT_ASSERT(std::equal(expected2,expected2+4,arr2->getConstPointer()));
1975   arr2->decrRef();
1976   arr->decrRef();
1977   m1->decrRef();
1978   m0->decrRef();
1979 }
1980
1981 void MEDCouplingBasicsTest4::testBuildDescendingConnec2()
1982 {
1983   MEDCouplingUMesh *mesh=build2DTargetMesh_1();
1984   DataArrayIdType *desc=DataArrayIdType::New();
1985   DataArrayIdType *descIndx=DataArrayIdType::New();
1986   DataArrayIdType *revDesc=DataArrayIdType::New();
1987   DataArrayIdType *revDescIndx=DataArrayIdType::New();
1988   //
1989   MEDCouplingUMesh *mesh2=mesh->buildDescendingConnectivity2(desc,descIndx,revDesc,revDescIndx);
1990   mesh2->checkConsistencyLight();
1991   CPPUNIT_ASSERT_EQUAL(1,mesh2->getMeshDimension());
1992   CPPUNIT_ASSERT_EQUAL(13,(int)mesh2->getNumberOfCells());
1993   CPPUNIT_ASSERT_EQUAL(ToIdType(14),revDescIndx->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(14,(int)revDescIndx->getNumberOfTuples());
1994   CPPUNIT_ASSERT_EQUAL(ToIdType(6),descIndx->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(6,(int)descIndx->getNumberOfTuples());
1995   CPPUNIT_ASSERT_EQUAL(ToIdType(18),desc->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(18,(int)desc->getNumberOfTuples());
1996   CPPUNIT_ASSERT_EQUAL(ToIdType(18),revDesc->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(18,(int)revDesc->getNumberOfTuples());
1997   const mcIdType expected1[18]={1,2,3,4,-3,5,6, 7,8,-5,9,10,-2,11, 12,13,-7,-10};
1998   CPPUNIT_ASSERT(std::equal(expected1,expected1+18,desc->getConstPointer()));
1999   const mcIdType expected2[6]={0,4,7,10,14,18};
2000   CPPUNIT_ASSERT(std::equal(expected2,expected2+6,descIndx->getConstPointer()));
2001   const mcIdType expected3[14]={0,1,3,5,6,8,9,11,12,13,15,16,17,18};
2002   CPPUNIT_ASSERT(std::equal(expected3,expected3+14,revDescIndx->getConstPointer()));
2003   const mcIdType expected4[18]={0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4};
2004   CPPUNIT_ASSERT(std::equal(expected4,expected4+18,revDesc->getConstPointer()));
2005   DataArrayIdType *conn=mesh2->getNodalConnectivity();
2006   DataArrayIdType *connIndex=mesh2->getNodalConnectivityIndex();
2007   const mcIdType expected5[14]={0,3,6,9,12,15,18,21,24,27,30,33,36,39};
2008   CPPUNIT_ASSERT(std::equal(expected5,expected5+14,connIndex->getConstPointer()));
2009   const mcIdType expected6[39]={1, 0, 3, 1, 3, 4, 1, 4, 1, 1, 1, 0, 1, 4, 2, 1, 2, 1, 1, 4, 5, 1, 5, 2, 1, 6, 7, 1, 7, 4, 1, 3, 6, 1, 7, 8, 1, 8, 5};
2010   CPPUNIT_ASSERT(std::equal(expected6,expected6+39,conn->getConstPointer()));
2011   //
2012   desc->decrRef();
2013   descIndx->decrRef();
2014   revDesc->decrRef();
2015   revDescIndx->decrRef();
2016   mesh2->decrRef();
2017   mesh->decrRef();
2018 }
2019
2020 void MEDCouplingBasicsTest4::testIntersect2DMeshesTmp1()
2021 {
2022   MEDCouplingCMesh *m1c=MEDCouplingCMesh::New();
2023   DataArrayDouble *coordX=DataArrayDouble::New();
2024   const double arrX[4]={-1., 1., 2., 4.};
2025   coordX->alloc(4,1);
2026   std::copy(arrX,arrX+4,coordX->getPointer());
2027   m1c->setCoordsAt(0,coordX);
2028   DataArrayDouble *coordY=DataArrayDouble::New();
2029   const double arrY[4]={-2., 2., 4., 8.};
2030   coordY->alloc(4,1);
2031   std::copy(arrY,arrY+4,coordY->getPointer());
2032   m1c->setCoordsAt(1,coordY);
2033   MEDCouplingUMesh *m1=m1c->buildUnstructured();
2034   const mcIdType subPart1[3]={3,4,5};
2035   MEDCouplingUMesh *m1bis=static_cast<MEDCouplingUMesh *>(m1->buildPartOfMySelf(subPart1,subPart1+3,false));
2036   MEDCouplingUMesh *m2tmp=static_cast<MEDCouplingUMesh *>(m1->deepCopy());
2037   const mcIdType subPart2[3]={0,1,2};
2038   MEDCouplingUMesh *m2=static_cast<MEDCouplingUMesh *>(m2tmp->buildPartOfMySelf(subPart2,subPart2+3,false));
2039   const double vec[2]={0.5,0.5};
2040   m2->translate(vec);
2041   // End of construction of input meshes m1bis and m2 -> start of specific part of the test
2042   DataArrayIdType *d1=0,*d2=0;
2043   MEDCouplingUMesh *m3=MEDCouplingUMesh::Intersect2DMeshes(m1bis,m2,1e-10,d1,d2);
2044   const mcIdType expected1[8]={0,0,1,1,1,2,2,2};
2045   const mcIdType expected2[8]={0,-1,0,1,-1,1,2,-1};
2046  CPPUNIT_ASSERT_EQUAL(8,(int)d1->getNumberOfTuples());
2047  CPPUNIT_ASSERT_EQUAL(8,(int)d2->getNumberOfTuples());
2048   CPPUNIT_ASSERT_EQUAL(8,(int)m3->getNumberOfCells());
2049   CPPUNIT_ASSERT_EQUAL(22,(int)m3->getNumberOfNodes());
2050   CPPUNIT_ASSERT_EQUAL(2,m3->getSpaceDimension());
2051   CPPUNIT_ASSERT(std::equal(expected1,expected1+8,d1->getConstPointer()));
2052   CPPUNIT_ASSERT(std::equal(expected2,expected2+8,d2->getConstPointer()));
2053   const mcIdType expected3[44]={5,17,1,16,12,5,16,0,4,5,17,12,5,18,1,17,13,5,19,2,18,13,5,17,5,6,19,13,5,20,2,19,14,5,21,3,20,14,5,19,6,7,21,14};
2054   const mcIdType expected4[9]={0,5,12,17,22,28,33,38,44};
2055   const double expected5[44]={-1.0,2.0,1.0,2.0,2.0,2.0,4.0,2.0,-1.0,4.0,1.0,4.0,2.0,4.0,4.0,4.0,-0.5,-1.5,1.5,-1.5,2.5,-1.5,4.5,-1.5,-0.5,2.5,1.5,2.5,2.5,2.5,4.5,2.5,-0.5,2.0,1.0,2.5,1.5,2.0,2.0,2.5,2.5,2.0,4.0,2.5};
2056   CPPUNIT_ASSERT_EQUAL(44,(int)m3->getNodalConnectivity()->getNumberOfTuples());
2057   CPPUNIT_ASSERT_EQUAL(9,(int)m3->getNodalConnectivityIndex()->getNumberOfTuples());
2058   CPPUNIT_ASSERT(std::equal(expected3,expected3+44,m3->getNodalConnectivity()->getConstPointer()));
2059   CPPUNIT_ASSERT(std::equal(expected4,expected4+9,m3->getNodalConnectivityIndex()->getConstPointer()));
2060   for(int i=0;i<44;i++)
2061     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected5[i],m3->getCoords()->getIJ(0,i),1e-12);
2062   d1->decrRef();
2063   d2->decrRef();
2064   m3->decrRef();
2065   //
2066   m2->decrRef();
2067   m2tmp->decrRef();
2068   m1bis->decrRef();
2069   m1->decrRef();
2070   coordX->decrRef();
2071   coordY->decrRef();
2072   m1c->decrRef();
2073 }
2074
2075 void MEDCouplingBasicsTest4::testFindNodesOnLine1()
2076 {
2077   MEDCouplingUMesh *mesh=build2DTargetMesh_1();
2078   const double pt[2]={-0.3,-0.3};
2079   const double pt2[3]={0.,0.,0.};
2080   const double pt3[3]={-0.3,0.,0.};
2081   const double vec[2]={0.,1.};
2082   const double vec2[3]={1.,0.,0.};
2083   const double vec3[3]={0.,1.,1.};
2084   const mcIdType expected1[3]={0,3,6};
2085   std::vector<mcIdType> res;
2086   mesh->findNodesOnLine(pt,vec,1e-12,res);
2087   CPPUNIT_ASSERT_EQUAL(3,(int)res.size());
2088   CPPUNIT_ASSERT(std::equal(expected1,expected1+3,res.begin()));
2089   res.clear();
2090   //
2091   mesh->changeSpaceDimension(3);
2092   mesh->rotate(pt2,vec2,M_PI/4.);
2093   mesh->findNodesOnLine(pt3,vec3,1e-12,res);
2094   CPPUNIT_ASSERT_EQUAL(3,(int)res.size());
2095   CPPUNIT_ASSERT(std::equal(expected1,expected1+3,res.begin()));
2096   //
2097   mesh->decrRef();
2098 }
2099
2100 void MEDCouplingBasicsTest4::testIntersect2DMeshesTmp2()
2101 {
2102   MEDCouplingCMesh *m1c=MEDCouplingCMesh::New();
2103   DataArrayDouble *coordsX1=DataArrayDouble::New();
2104   const double arrX1[4]={ 0., 1., 1.5, 2. };
2105   coordsX1->alloc(4,1);
2106   std::copy(arrX1,arrX1+4,coordsX1->getPointer());
2107   m1c->setCoordsAt(0,coordsX1);
2108   DataArrayDouble *coordsY1=DataArrayDouble::New();
2109   const double arrY1[3]={ 0., 1.5, 3.};
2110   coordsY1->alloc(3,1);
2111   std::copy(arrY1,arrY1+3,coordsY1->getPointer());
2112   m1c->setCoordsAt(1,coordsY1);
2113   MEDCouplingUMesh *m1=m1c->buildUnstructured();
2114   //
2115   MEDCouplingCMesh *m2c=MEDCouplingCMesh::New();
2116   DataArrayDouble *coordsX2=DataArrayDouble::New();
2117   const double arrX2[3]={ 0., 1., 2. };
2118   coordsX2->alloc(3,1);
2119   std::copy(arrX2,arrX2+3,coordsX2->getPointer());
2120   m2c->setCoordsAt(0,coordsX2);
2121   DataArrayDouble *coordsY2=DataArrayDouble::New();
2122   coordsY2->alloc(3,1);
2123   const double arrY2[3]={ 0., 1., 3.};
2124   std::copy(arrY2,arrY2+3,coordsY2->getPointer());
2125   m2c->setCoordsAt(1,coordsY2);
2126   MEDCouplingUMesh *m2=m2c->buildUnstructured();
2127   //
2128   DataArrayIdType *d1=0,*d2=0;
2129   MEDCouplingUMesh *m3=MEDCouplingUMesh::Intersect2DMeshes(m1,m2,1e-10,d1,d2);
2130   const mcIdType expected1[9]={0,0,1,1,2,2,3,4,5};
2131   const mcIdType expected2[9]={0,2,1,3,1,3,2,3,3};
2132  CPPUNIT_ASSERT_EQUAL(9,(int)d1->getNumberOfTuples());
2133  CPPUNIT_ASSERT_EQUAL(9,(int)d2->getNumberOfTuples());
2134   CPPUNIT_ASSERT_EQUAL(9,(int)m3->getNumberOfCells());
2135   CPPUNIT_ASSERT_EQUAL(22,(int)m3->getNumberOfNodes());
2136   CPPUNIT_ASSERT_EQUAL(2,m3->getSpaceDimension());
2137   CPPUNIT_ASSERT(std::equal(expected1,expected1+9,d1->getConstPointer()));
2138   CPPUNIT_ASSERT(std::equal(expected2,expected2+9,d2->getConstPointer()));
2139   const mcIdType expected3[45]={5,16,13,12,15,5,15,4,5,16,5,21,2,13,16,5,16,5,6,21,5,17,14,2,21,5,21,6,7,17,5,4,18,19,5,5,5,19,10,6,5,6,10,20,7};
2140   const mcIdType expected4[10]={0,5,10,15,20,25,30,35,40,45};
2141   const double expected5[44]={0.0,0.0,1.0,0.0,1.5,0.0,2.0,0.0,0.0,1.5,1.0,1.5,1.5,1.5,2.0,1.5,0.0,3.0,1.0,3.0,1.5,3.0,2.0,3.0,0.0,0.0,1.0,0.0,2.0,0.0,0.0,1.0,1.0,1.0,2.0,1.0,0.0,3.0,1.0,3.0,2.0,3.0,1.5,1.0};
2142   CPPUNIT_ASSERT_EQUAL(45,(int)m3->getNodalConnectivity()->getNumberOfTuples());
2143   CPPUNIT_ASSERT_EQUAL(10,(int)m3->getNodalConnectivityIndex()->getNumberOfTuples());
2144   CPPUNIT_ASSERT(std::equal(expected3,expected3+45,m3->getNodalConnectivity()->getConstPointer()));
2145   CPPUNIT_ASSERT(std::equal(expected4,expected4+10,m3->getNodalConnectivityIndex()->getConstPointer()));
2146   for(int i=0;i<44;i++)
2147     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected5[i],m3->getCoords()->getIJ(0,i),1e-12);
2148   d1->decrRef();
2149   d2->decrRef();
2150   m3->decrRef();
2151   //
2152   m1c->decrRef();
2153   coordsX1->decrRef();
2154   coordsY1->decrRef();
2155   m1->decrRef();
2156   m2c->decrRef();
2157   coordsX2->decrRef();
2158   coordsY2->decrRef();
2159   m2->decrRef();
2160 }
2161
2162 void MEDCouplingBasicsTest4::testBuildPartOfMySelfSafe1()
2163 {
2164   MEDCouplingUMesh *mesh=build2DTargetMesh_1();
2165   const mcIdType input1[4]={0,-1,4,2};
2166   const mcIdType input2[4]={0,4,5,4};
2167   CPPUNIT_ASSERT_THROW(mesh->buildPartOfMySelf(input1,input1+4,true),INTERP_KERNEL::Exception);
2168   CPPUNIT_ASSERT_THROW(mesh->buildPartOfMySelf(input2,input2+4,true),INTERP_KERNEL::Exception);
2169   mesh->decrRef();
2170 }
2171
2172 void MEDCouplingBasicsTest4::testIntersect2DMeshesTmp3()
2173 {
2174   double m1Coords[50]={0.,0.,1.,0.,1.5,0.,0.,1.,0.,1.5,-1.,0.,-1.5,0.,0.,-1,0.,-1.5,0.5,0.,1.25,0.,0.70710678118654757,0.70710678118654757,1.0606601717798214,1.0606601717798214,0.,0.5,0.,1.25,-0.70710678118654757,0.70710678118654757,-1.0606601717798214,1.0606601717798214,-0.5,0.,-1.25,0.,-0.70710678118654757,-0.70710678118654757,-1.0606601717798214,-1.0606601717798214,0.,-0.5,0.,-1.25,0.70710678118654757,-0.70710678118654757,1.0606601717798214,-1.0606601717798214};
2175   mcIdType m1Conn[56]={0,3,1,13,11,9, 3,4,2,1,14,12,10,11, 5,3,0,15,13,17, 6,4,3,5,16,14,15,18, 5,0,7,17,21,19, 6,5,7,8,18,19,22,20, 0,1,7,9,23,21, 1,2,8,7,10,24,22,23};
2176   MEDCouplingUMesh *m1=MEDCouplingUMesh::New();
2177   m1->setMeshDimension(2);
2178   m1->allocateCells(8);
2179   m1->insertNextCell(INTERP_KERNEL::NORM_TRI6,6,m1Conn);
2180   m1->insertNextCell(INTERP_KERNEL::NORM_QUAD8,8,m1Conn+6);
2181   m1->insertNextCell(INTERP_KERNEL::NORM_TRI6,6,m1Conn+14);
2182   m1->insertNextCell(INTERP_KERNEL::NORM_QUAD8,8,m1Conn+20);
2183   m1->insertNextCell(INTERP_KERNEL::NORM_TRI6,6,m1Conn+28);
2184   m1->insertNextCell(INTERP_KERNEL::NORM_QUAD8,8,m1Conn+34);
2185   m1->insertNextCell(INTERP_KERNEL::NORM_TRI6,6,m1Conn+42);
2186   m1->insertNextCell(INTERP_KERNEL::NORM_QUAD8,8,m1Conn+48);
2187   m1->finishInsertingCells();
2188   DataArrayDouble *myCoords1=DataArrayDouble::New();
2189   myCoords1->alloc(25,2);
2190   std::copy(m1Coords,m1Coords+50,myCoords1->getPointer());
2191   m1->setCoords(myCoords1);
2192   myCoords1->decrRef();
2193   //
2194   double m2Coords[30]={0.,0.,1.1,0.,1.1,1.,0.,1.,1.7,0.,1.7,1.,-1.1,1.,-1.1,0.,-1.7,0.,-1.7,1.,-1.7,-1,-1.1,-1.,0.,-1.,1.1,-1,1.7,-1.};
2195   mcIdType m2Conn[32]={0,3,2,1, 1,2,5,4, 7,6,3,0, 8,9,6,7, 7,0,12,11, 8,7,11,10, 0,1,13,12, 1,4,14,13};
2196   MEDCouplingUMesh *m2=MEDCouplingUMesh::New();
2197   m2->setMeshDimension(2);
2198   m2->allocateCells(8);
2199   for(int i=0;i<8;i++)
2200     m2->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,m2Conn+4*i);
2201   m2->finishInsertingCells();
2202   DataArrayDouble *myCoords2=DataArrayDouble::New();
2203   myCoords2->alloc(15,2);
2204   std::copy(m2Coords,m2Coords+30,myCoords2->getPointer());
2205   m2->setCoords(myCoords2);
2206   myCoords2->decrRef();
2207   //
2208   DataArrayIdType *d1=0,*d2=0;
2209   MEDCouplingUMesh *m3=MEDCouplingUMesh::Intersect2DMeshes(m1,m2,1e-10,d1,d2);
2210   m3->unPolyze();
2211   const mcIdType expected1[16]={0,1,1,1,2,3,3,3,4,5,5,5,6,7,7,7};
2212   const mcIdType expected2[16]={0,0,1,-1,2,2,3,-1,4,4,5,-1,6,6,7,-1};
2213   CPPUNIT_ASSERT_EQUAL(16,(int)d1->getNumberOfTuples());
2214   CPPUNIT_ASSERT_EQUAL(16,(int)d2->getNumberOfTuples());
2215   CPPUNIT_ASSERT_EQUAL(16,(int)m3->getNumberOfCells());
2216   CPPUNIT_ASSERT_EQUAL(104,(int)m3->getNumberOfNodes());
2217   CPPUNIT_ASSERT_EQUAL(2,m3->getSpaceDimension());
2218   CPPUNIT_ASSERT(std::equal(expected1,expected1+16,d1->getConstPointer()));
2219   CPPUNIT_ASSERT(std::equal(expected2,expected2+16,d2->getConstPointer()));
2220   const mcIdType expected3[136]={6,28,1,25,44,45,46,8,26,1,28,27,47,48,49,50,8,40,2,26,27,51,52,53,54,8,28,4,40,27,55,56,57,58,6,28,25,5,59,60,61,8,28,5,32,31,62,63,64,65,8,32,6,41,31,66,67,68,69,8,41,4,28,31,70,71,72,73,6,25,37,5,74,75,76,8,32,5,37,36,77,78,79,80,8,42,6,32,36,81,82,83,84,8,37,8,42,36,85,86,87,88,6,1,37,25,89,90,91,8,37,1,26,38,92,93,94,95,8,26,2,43,38,96,97,98,99,8,43,8,37,38,100,101,102,103};
2221   const mcIdType expected4[17]={0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136};
2222   const double expected5[208]={0.,0.,1.,0.,1.5,0.,0.,1.,0.,1.5,-1.,0.,-1.5,0.,0.,-1.,0.,-1.5,0.5,0.,1.25,0.,0.7071067811865476,0.7071067811865476,1.0606601717798214,1.0606601717798214,0.,0.5,0.,1.25,-0.7071067811865476,0.7071067811865476,-1.0606601717798214,1.0606601717798214,-0.5,0.,-1.25,0.,-0.7071067811865476,-0.7071067811865476,-1.0606601717798214,-1.0606601717798214,0.,-0.5,0.,-1.25,0.7071067811865476,-0.7071067811865476,1.0606601717798214,-1.0606601717798214,0.,0.,1.1,0.,1.1,1.,0.,1.,1.7,0.,1.7,1.,-1.1,1.,-1.1,0.,-1.7,0.,-1.7,1.,-1.7,-1.,-1.1,-1.,0.,-1.,1.1,-1.,1.7,-1.,1.118033988749895,1.,-1.118033988749895,1.,-1.118033988749895,-1.,1.118033988749895,-1.,0.7071067811865477,0.7071067811865476,0.5,0.,0.,0.5,1.05,0.,0.7071067811865475,0.7071067811865477,0.55,1.,1.1,0.5,1.4012585384440737,0.535233134659635,1.3,0.,1.1,0.5,1.1090169943749475,1.,0.,1.25,0.6123724356957946,1.369306393762915,1.1090169943749475,1.,0.55,1.,0.,0.5,-0.5,0.,-0.7071067811865477,0.7071067811865476,-0.7071067811865475,0.7071067811865477,-1.05,0.,-1.1,0.5,-0.55,1.,-1.3,0.,-1.4012585384440737,0.5352331346596344,-1.1090169943749475,1.,-1.1,0.5,-0.6123724356957941,1.3693063937629155,0.,1.25,-0.55,1.,-1.1090169943749475,1.,0.,-0.5,-0.7071067811865475,-0.7071067811865477,-0.5,0.,-1.05,0.,-0.7071067811865478,-0.7071067811865475,-0.55,-1.,-1.1,-0.5,-1.4012585384440734,-0.5352331346596354,-1.3,0.,-1.1,-0.5,-1.1090169943749475,-1.,0.,-1.25,-0.6123724356957945,-1.369306393762915,-1.1090169943749475,-1.,-0.55,-1.,0.7071067811865475,-0.7071067811865477,0.,-0.5,0.5,0.,0.7071067811865477,-0.7071067811865475,1.05,0.,1.1,-0.5,0.55,-1.,1.3,0.,1.4012585384440737,-0.535233134659635,1.1090169943749475,-1.,1.1,-0.5,0.6123724356957946,-1.369306393762915,0.,-1.25,0.55,-1.,1.1090169943749475,-1.0};
2223   CPPUNIT_ASSERT_EQUAL(136,(int)m3->getNodalConnectivity()->getNumberOfTuples());
2224   CPPUNIT_ASSERT_EQUAL(17,(int)m3->getNodalConnectivityIndex()->getNumberOfTuples());
2225   CPPUNIT_ASSERT(std::equal(expected3,expected3+136,m3->getNodalConnectivity()->getConstPointer()));
2226   CPPUNIT_ASSERT(std::equal(expected4,expected4+17,m3->getNodalConnectivityIndex()->getConstPointer()));
2227   for(int i=0;i<208;i++)
2228     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected5[i],m3->getCoords()->getIJ(0,i),1e-12);
2229   d1->decrRef();
2230   d2->decrRef();
2231   m3->decrRef();
2232   //
2233   m1->decrRef();
2234   m2->decrRef();
2235 }