src/MEDCoupling/Test/MEDCouplingRemapperTest.cxx

   1 // Copyright (C) 2007-2012  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.
   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
  20 #include "MEDCouplingRemapperTest.hxx"
  21 #include "MEDCouplingUMesh.hxx"
  22 #include "MEDCouplingExtrudedMesh.hxx"
  23 #include "MEDCouplingFieldDouble.hxx"
  24 #include "MEDCouplingFieldTemplate.hxx"
  25 #include "MEDCouplingMemArray.hxx"
  26 #include "MEDCouplingRemapper.hxx"
  27
  28 #include "MEDCouplingBasicsTest.hxx"
  29
  30 #include <cmath>
  31 #include <numeric>
  32
  33 using namespace ParaMEDMEM;
  34
  35 void MEDCouplingRemapperTest::test2DInterpP0P0_1()
  36 {
  37   MEDCouplingUMesh *sourceMesh=MEDCouplingBasicsTest::build2DSourceMesh_1();
  38   MEDCouplingUMesh *targetMesh=MEDCouplingBasicsTest::build2DTargetMesh_1();
  39   //
  40   MEDCouplingRemapper remapper;
  41   remapper.setPrecision(1e-12);
  42   remapper.setIntersectionType(INTERP_KERNEL::Triangulation);
  43   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
  44
  45   MEDCouplingFieldDouble *srcField=MEDCouplingFieldDouble::New(ON_CELLS);
  46   srcField->setNature(ConservativeVolumic);
  47   srcField->setMesh(sourceMesh);
  48   DataArrayDouble *array=DataArrayDouble::New();
  49   array->alloc(sourceMesh->getNumberOfCells(),1);
  50   srcField->setArray(array);
  51   double *ptr=array->getPointer();
  52   for(int i=0;i<sourceMesh->getNumberOfCells();i++)
  53     ptr[i]=(double)(i+7);
  54   array->decrRef();
  55   MEDCouplingFieldDouble *trgfield=remapper.transferField(srcField,4.57);
  56   const double *values=trgfield->getArray()->getConstPointer();
  57   const double valuesExpected[5]={7.5 ,7. ,7.,8.,7.5};
  58   CPPUNIT_ASSERT_EQUAL(5,trgfield->getArray()->getNumberOfTuples());
  59   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
  60   for(int i0=0;i0<5;i0++)
  61     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected[i0],values[i0],1e-12);
  62   trgfield->decrRef();
  63   //
  64   srcField->setNature(IntegralGlobConstraint);
  65   trgfield=remapper.transferField(srcField,4.57);
  66   values=trgfield->getArray()->getConstPointer();
  67   const double valuesExpected2[5]={3.75 ,1.75 ,1.75,4.,3.75};
  68   CPPUNIT_ASSERT_EQUAL(5,trgfield->getArray()->getNumberOfTuples());
  69   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
  70   for(int i0=0;i0<5;i0++)
  71     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected2[i0],values[i0],1e-12);
  72   trgfield->decrRef();
  73   //
  74   srcField->setNature(ConservativeVolumic);
  75   trgfield=remapper.transferField(srcField,4.57);
  76   values=trgfield->getArray()->getConstPointer();
  77   CPPUNIT_ASSERT_EQUAL(5,trgfield->getArray()->getNumberOfTuples());
  78   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
  79   for(int i0=0;i0<5;i0++)
  80     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected[i0],values[i0],1e-12);
  81   trgfield->decrRef();
  82   //
  83   srcField->setNature(IntegralGlobConstraint);
  84   trgfield=remapper.transferField(srcField,4.57);
  85   values=trgfield->getArray()->getConstPointer();
  86   CPPUNIT_ASSERT_EQUAL(5,trgfield->getArray()->getNumberOfTuples());
  87   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
  88   for(int i0=0;i0<5;i0++)
  89     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected2[i0],values[i0],1e-12);
  90   trgfield->decrRef();
  91   //
  92   srcField->setNature(Integral);
  93   trgfield=remapper.transferField(srcField,4.57);
  94   values=trgfield->getArray()->getConstPointer();
  95   CPPUNIT_ASSERT_EQUAL(5,trgfield->getArray()->getNumberOfTuples());
  96   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
  97   for(int i0=0;i0<5;i0++)
  98     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected2[i0],values[i0],1e-12);
  99   trgfield->decrRef();
 100   //
 101   srcField->setNature(RevIntegral);
 102   trgfield=remapper.transferField(srcField,4.57);
 103   values=trgfield->getArray()->getConstPointer();
 104   CPPUNIT_ASSERT_EQUAL(5,trgfield->getArray()->getNumberOfTuples());
 105   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 106   for(int i0=0;i0<5;i0++)
 107     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected[i0],values[i0],1e-12);
 108   trgfield->decrRef();
 109   //
 110   srcField->decrRef();
 111   //clean up
 112   sourceMesh->decrRef();
 113   targetMesh->decrRef();
 114 }
 115
 116 void MEDCouplingRemapperTest::test2DInterpP0P0R_1()
 117 {
 118   MEDCouplingUMesh *sourceMesh=MEDCouplingBasicsTest::build2DSourceMesh_1();
 119   MEDCouplingUMesh *targetMesh=MEDCouplingBasicsTest::build2DTargetMesh_1();
 120   //
 121   MEDCouplingRemapper remapper;
 122   remapper.setPrecision(1e-12);
 123   remapper.setIntersectionType(INTERP_KERNEL::Triangulation);
 124   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
 125
 126   MEDCouplingFieldDouble *targetField=MEDCouplingFieldDouble::New(ON_CELLS);
 127   targetField->setNature(ConservativeVolumic);
 128   targetField->setMesh(sourceMesh);
 129   DataArrayDouble *array=DataArrayDouble::New();
 130   array->alloc(targetMesh->getNumberOfCells(),1);
 131   targetField->setArray(array);
 132   double *ptr=array->getPointer();
 133   for(int i=0;i<targetMesh->getNumberOfCells();i++)
 134     ptr[i]=(double)(i+7);
 135   array->decrRef();
 136   //
 137   MEDCouplingFieldDouble *srcfield=remapper.reverseTransferField(targetField,4.57);
 138   const double *values=srcfield->getArray()->getConstPointer();
 139   const double valuesExpected[2]={8.75 ,9.5};
 140   CPPUNIT_ASSERT_EQUAL(2,srcfield->getArray()->getNumberOfTuples());
 141   CPPUNIT_ASSERT_EQUAL(1,srcfield->getArray()->getNumberOfComponents());
 142   for(int i0=0;i0<2;i0++)
 143     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected[i0],values[i0],1e-12);
 144   srcfield->decrRef();
 145   //
 146   targetField->setNature(IntegralGlobConstraint);
 147   srcfield=remapper.reverseTransferField(targetField,4.57);
 148   values=srcfield->getArray()->getConstPointer();
 149   const double valuesExpected2[2]={26., 19.};
 150   CPPUNIT_ASSERT_EQUAL(2,srcfield->getArray()->getNumberOfTuples());
 151   CPPUNIT_ASSERT_EQUAL(1,srcfield->getArray()->getNumberOfComponents());
 152   for(int i0=0;i0<2;i0++)
 153     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected2[i0],values[i0],1e-12);
 154   srcfield->decrRef();
 155   //
 156   targetField->decrRef();
 157   //clean up
 158   sourceMesh->decrRef();
 159   targetMesh->decrRef();
 160 }
 161
 162 void MEDCouplingRemapperTest::test1DInterp_1()
 163 {
 164   MEDCouplingUMesh *sourceMesh=MEDCouplingBasicsTest::build1DSourceMesh_2();
 165   MEDCouplingUMesh *targetMesh=MEDCouplingBasicsTest::build1DTargetMesh_2();
 166   //
 167   MEDCouplingRemapper remapper;
 168   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
 169   MEDCouplingFieldDouble *srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 170   srcField->setNature(ConservativeVolumic);
 171   srcField->setMesh(sourceMesh);
 172   DataArrayDouble *array=DataArrayDouble::New();
 173   array->alloc(sourceMesh->getNumberOfCells(),1);
 174   srcField->setArray(array);
 175   double *ptr=array->getPointer();
 176   for(int i=0;i<sourceMesh->getNumberOfCells();i++)
 177     ptr[i]=(double)(i+7);
 178   array->decrRef();
 179   //
 180   MEDCouplingFieldDouble *trgfield=remapper.transferField(srcField,4.57);
 181   const double *values=trgfield->getArray()->getConstPointer();
 182   const double valuesExpected1[2]={9.0540540540540526,7.4};
 183   CPPUNIT_ASSERT_EQUAL(2,trgfield->getArray()->getNumberOfTuples());
 184   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 185   for(int i0=0;i0<2;i0++)
 186     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected1[i0],values[i0],1e-12);
 187   trgfield->decrRef();
 188   const double valuesExpected2[2]={24.75,5.75};
 189   srcField->setNature(Integral);
 190   trgfield=remapper.transferField(srcField,4.57);
 191   values=trgfield->getArray()->getConstPointer();
 192   CPPUNIT_ASSERT_EQUAL(2,trgfield->getArray()->getNumberOfTuples());
 193   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 194   for(int i0=0;i0<2;i0++)
 195     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected2[i0],values[i0],1e-12);
 196   trgfield->decrRef();
 197   //
 198   const double valuesExpected3[2]={24.75,9.25};
 199   srcField->setNature(IntegralGlobConstraint);
 200   trgfield=remapper.transferField(srcField,4.57);
 201   values=trgfield->getArray()->getConstPointer();
 202   CPPUNIT_ASSERT_EQUAL(2,trgfield->getArray()->getNumberOfTuples());
 203   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 204   for(int i0=0;i0<2;i0++)
 205     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected3[i0],values[i0],1e-12);
 206   trgfield->decrRef();
 207   //
 208   const double valuesExpected4[2]={7.4444444444444446,7.4};
 209   srcField->setNature(RevIntegral);
 210   trgfield=remapper.transferField(srcField,4.57);
 211   values=trgfield->getArray()->getConstPointer();
 212   CPPUNIT_ASSERT_EQUAL(2,trgfield->getArray()->getNumberOfTuples());
 213   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 214   for(int i0=0;i0<2;i0++)
 215     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected4[i0],values[i0],1e-12);
 216   trgfield->decrRef();
 217   //
 218   srcField->decrRef();
 219   sourceMesh->decrRef();
 220   targetMesh->decrRef();
 221   //2D Curve
 222   sourceMesh=MEDCouplingBasicsTest::build2DCurveSourceMesh_2();
 223   targetMesh=MEDCouplingBasicsTest::build2DCurveTargetMesh_2();
 224   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
 225   srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 226   srcField->setNature(ConservativeVolumic);
 227   srcField->setMesh(sourceMesh);
 228   array=DataArrayDouble::New();
 229   array->alloc(sourceMesh->getNumberOfCells(),1);
 230   srcField->setArray(array);
 231   ptr=array->getPointer();
 232   for(int i=0;i<sourceMesh->getNumberOfCells();i++)
 233     ptr[i]=(double)(i+7);
 234   array->decrRef();
 235   //
 236   trgfield=remapper.transferField(srcField,4.57);
 237   values=trgfield->getArray()->getConstPointer();
 238   CPPUNIT_ASSERT_EQUAL(2,trgfield->getArray()->getNumberOfTuples());
 239   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 240   for(int i0=0;i0<2;i0++)
 241     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected1[i0],values[i0],1e-12);
 242   trgfield->decrRef();
 243   srcField->setNature(Integral);
 244   trgfield=remapper.transferField(srcField,4.57);
 245   values=trgfield->getArray()->getConstPointer();
 246   CPPUNIT_ASSERT_EQUAL(2,trgfield->getArray()->getNumberOfTuples());
 247   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 248   for(int i0=0;i0<2;i0++)
 249     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected2[i0],values[i0],1e-12);
 250   trgfield->decrRef();
 251   //
 252   srcField->setNature(IntegralGlobConstraint);
 253   trgfield=remapper.transferField(srcField,4.57);
 254   values=trgfield->getArray()->getConstPointer();
 255   CPPUNIT_ASSERT_EQUAL(2,trgfield->getArray()->getNumberOfTuples());
 256   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 257   for(int i0=0;i0<2;i0++)
 258     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected3[i0],values[i0],1e-12);
 259   trgfield->decrRef();
 260   //
 261   srcField->setNature(RevIntegral);
 262   trgfield=remapper.transferField(srcField,4.57);
 263   values=trgfield->getArray()->getConstPointer();
 264   CPPUNIT_ASSERT_EQUAL(2,trgfield->getArray()->getNumberOfTuples());
 265   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 266   for(int i0=0;i0<2;i0++)
 267     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected4[i0],values[i0],1e-12);
 268   trgfield->decrRef();
 269   //
 270   srcField->decrRef();
 271   sourceMesh->decrRef();
 272   targetMesh->decrRef();
 273 }
 274
 275 void MEDCouplingRemapperTest::test2DInterpMultiMethods()
 276 {
 277   MEDCouplingUMesh *sourceMesh=MEDCouplingBasicsTest::build2DSourceMesh_1();
 278   MEDCouplingUMesh *targetMesh=MEDCouplingBasicsTest::build2DTargetMesh_1();
 279   //
 280   MEDCouplingRemapper remapper;
 281   remapper.setPrecision(1e-12);
 282   remapper.setIntersectionType(INTERP_KERNEL::Triangulation);
 283   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
 284
 285   MEDCouplingFieldDouble *srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 286   srcField->setNature(ConservativeVolumic);
 287   srcField->setMesh(sourceMesh);
 288   DataArrayDouble *array=DataArrayDouble::New();
 289   array->alloc(sourceMesh->getNumberOfCells(),1);
 290   srcField->setArray(array);
 291   double *ptr=array->getPointer();
 292   for(int i=0;i<sourceMesh->getNumberOfCells();i++)
 293     ptr[i]=(double)(i+7);
 294   array->decrRef();
 295   MEDCouplingFieldDouble *trgfield=remapper.transferField(srcField,4.57);
 296   const double *values=trgfield->getArray()->getConstPointer();
 297   const double valuesExpected[5]={7.5 ,7. ,7.,8.,7.5};
 298   CPPUNIT_ASSERT_EQUAL(5,trgfield->getArray()->getNumberOfTuples());
 299   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 300   for(int i0=0;i0<5;i0++)
 301     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected[i0],values[i0],1e-12);
 302   trgfield->decrRef();
 303   srcField->decrRef();
 304   //
 305   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P1P0"));
 306   srcField=MEDCouplingFieldDouble::New(ON_NODES);
 307   srcField->setNature(ConservativeVolumic);
 308   srcField->setMesh(sourceMesh);
 309   array=DataArrayDouble::New();
 310   array->alloc(sourceMesh->getNumberOfNodes(),1);
 311   srcField->setArray(array);
 312   ptr=array->getPointer();
 313   for(int i=0;i<sourceMesh->getNumberOfNodes();i++)
 314     ptr[i]=(double)(i+7);
 315   array->decrRef();
 316   trgfield=remapper.transferField(srcField,4.57);
 317   values=trgfield->getArray()->getConstPointer();
 318   const double valuesExpected2[5]={7.,7.666666666666667,8.6666666666666661,8.8333333333333339,10.};
 319   CPPUNIT_ASSERT_EQUAL(5,trgfield->getArray()->getNumberOfTuples());
 320   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 321   for(int i0=0;i0<5;i0++)
 322     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected2[i0],values[i0],1e-12);
 323   trgfield->decrRef();
 324   srcField->decrRef();
 325   //
 326   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(targetMesh,sourceMesh,"P0P1"));
 327   srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 328   srcField->setNature(ConservativeVolumic);
 329   srcField->setMesh(targetMesh);
 330   array=DataArrayDouble::New();
 331   array->alloc(targetMesh->getNumberOfCells(),1);
 332   srcField->setArray(array);
 333   ptr=array->getPointer();
 334   for(int i=0;i<targetMesh->getNumberOfCells();i++)
 335     ptr[i]=(double)(i+7);
 336   array->decrRef();
 337   trgfield=remapper.transferField(srcField,4.57);
 338   values=trgfield->getArray()->getConstPointer();
 339   const double valuesExpected3[4]={7.5,8.5,10.,10.625};
 340   CPPUNIT_ASSERT_EQUAL(4,trgfield->getArray()->getNumberOfTuples());
 341   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 342   for(int i0=0;i0<4;i0++)
 343     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected3[i0],values[i0],1e-12);
 344   trgfield->decrRef();
 345   srcField->decrRef();
 346   //clean up
 347   sourceMesh->decrRef();
 348   targetMesh->decrRef();
 349   //
 350   sourceMesh=MEDCouplingBasicsTest::build2DSourceMesh_1();
 351   targetMesh=MEDCouplingBasicsTest::build2DTargetMesh_2();
 352   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P1P1"));
 353   srcField=MEDCouplingFieldDouble::New(ON_NODES);
 354   srcField->setNature(ConservativeVolumic);
 355   srcField->setMesh(sourceMesh);
 356   array=DataArrayDouble::New();
 357   array->alloc(sourceMesh->getNumberOfNodes(),1);
 358   srcField->setArray(array);
 359   ptr=array->getPointer();
 360   for(int i=0;i<sourceMesh->getNumberOfNodes();i++)
 361     ptr[i]=(double)(i+7);
 362   array->decrRef();
 363   trgfield=remapper.transferField(srcField,4.57);
 364   values=trgfield->getArray()->getConstPointer();
 365   const double valuesExpected4[9]={ 7.,7.35,8.,7.7,8.2857142857142865,
 366                                     9.5333333333333332,9.,9.7666666666666657,10.};
 367   CPPUNIT_ASSERT_EQUAL(9,trgfield->getArray()->getNumberOfTuples());
 368   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 369   for(int i0=0;i0<9;i0++)
 370     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected4[i0],values[i0],1e-12);
 371   trgfield->decrRef();
 372   srcField->decrRef();
 373   //clean up
 374   sourceMesh->decrRef();
 375   targetMesh->decrRef();
 376 }
 377
 378 void MEDCouplingRemapperTest::testMultiDimCombi()
 379 {
 380   // ------------- 2D
 381   MEDCouplingUMesh *sourceMesh=MEDCouplingBasicsTest::build2DSourceMesh_1();
 382   MEDCouplingUMesh *targetMesh=MEDCouplingBasicsTest::build2DTargetMesh_1();
 383   //
 384   MEDCouplingRemapper remapper;
 385   remapper.setPrecision(1e-12);
 386   remapper.setIntersectionType(INTERP_KERNEL::Triangulation);
 387   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
 388   MEDCouplingFieldDouble *srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 389   srcField->setNature(ConservativeVolumic);
 390   srcField->setMesh(sourceMesh);
 391   DataArrayDouble *array=DataArrayDouble::New();
 392   array->alloc(sourceMesh->getNumberOfCells(),1);
 393   srcField->setArray(array);
 394   double *ptr=array->getPointer();
 395   for(int i=0;i<sourceMesh->getNumberOfCells();i++)
 396     ptr[i]=(double)(i+7);
 397   array->decrRef();
 398   MEDCouplingFieldDouble *trgField=remapper.transferField(srcField,4.57);
 399   const double *values=trgField->getArray()->getConstPointer();
 400   const double valuesExpected[5]={7.5 ,7. ,7.,8.,7.5};
 401   CPPUNIT_ASSERT_EQUAL(5,trgField->getArray()->getNumberOfTuples());
 402   CPPUNIT_ASSERT_EQUAL(1,trgField->getArray()->getNumberOfComponents());
 403   for(int i0=0;i0<5;i0++)
 404     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected[i0],values[i0],1e-12);
 405   trgField->decrRef();
 406   srcField->decrRef();
 407   sourceMesh->decrRef();
 408   targetMesh->decrRef();
 409   // ------------- 3D Surf
 410   sourceMesh=MEDCouplingBasicsTest::build3DSurfSourceMesh_1();
 411   targetMesh=MEDCouplingBasicsTest::build3DSurfTargetMesh_1();
 412   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
 413   srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 414   srcField->setNature(ConservativeVolumic);
 415   srcField->setMesh(sourceMesh);
 416   array=DataArrayDouble::New();
 417   array->alloc(sourceMesh->getNumberOfCells(),1);
 418   srcField->setArray(array);
 419   ptr=array->getPointer();
 420   for(int i=0;i<sourceMesh->getNumberOfCells();i++)
 421     ptr[i]=(double)(i+8);
 422   array->decrRef();
 423   trgField=remapper.transferField(srcField,4.57);
 424   CPPUNIT_ASSERT_EQUAL(5,trgField->getArray()->getNumberOfTuples());
 425   CPPUNIT_ASSERT_EQUAL(1,trgField->getArray()->getNumberOfComponents());
 426   const double valuesExpected2[5]={8.5,8.,8.,9.,8.5};
 427   values=trgField->getArray()->getConstPointer();
 428   for(int i0=0;i0<5;i0++)
 429     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected2[i0],values[i0],1e-12);
 430   trgField->decrRef();
 431   srcField->decrRef();
 432   sourceMesh->decrRef();
 433   targetMesh->decrRef();
 434   // ------------- 3D
 435   sourceMesh=MEDCouplingBasicsTest::build3DSourceMesh_1();
 436   targetMesh=MEDCouplingBasicsTest::build3DTargetMesh_1();
 437   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
 438   srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 439   srcField->setNature(ConservativeVolumic);
 440   srcField->setMesh(sourceMesh);
 441   array=DataArrayDouble::New();
 442   array->alloc(sourceMesh->getNumberOfCells(),1);
 443   srcField->setArray(array);
 444   ptr=array->getPointer();
 445   for(int i=0;i<sourceMesh->getNumberOfCells();i++)
 446     ptr[i]=(double)(i+7);
 447   array->decrRef();
 448   trgField=remapper.transferField(srcField,4.57);
 449   CPPUNIT_ASSERT_EQUAL(8,trgField->getArray()->getNumberOfTuples());
 450   CPPUNIT_ASSERT_EQUAL(1,trgField->getArray()->getNumberOfComponents());
 451   const double valuesExpected3[8]={13.166666666666668, 13.888888888888888, 10.722222222222223, 10.870370370370372,
 452                                    14.555555555555555, 13.888888888888889, 14.444444444444443, 11.72222222222222};
 453   values=trgField->getArray()->getConstPointer();
 454   for(int i0=0;i0<8;i0++)
 455     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected3[i0],values[i0],1e-12);
 456   trgField->decrRef();
 457   srcField->decrRef();
 458   sourceMesh->decrRef();
 459   targetMesh->decrRef();
 460   // ------------- 3D -> 1D
 461   sourceMesh=MEDCouplingBasicsTest::build3DTargetMesh_1();
 462   targetMesh=MEDCouplingBasicsTest::build1DTargetMesh_1();
 463   remapper.setIntersectionType(INTERP_KERNEL::PointLocator);
 464   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
 465   srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 466   srcField->setNature(ConservativeVolumic);
 467   srcField->setMesh(sourceMesh);
 468   array=DataArrayDouble::New();
 469   array->alloc(sourceMesh->getNumberOfCells(),1);
 470   srcField->setArray(array);
 471   ptr=array->getPointer();
 472   for(int i=0;i<sourceMesh->getNumberOfCells();i++)
 473     ptr[i]=(double)(i+7);
 474   array->decrRef();
 475   trgField=remapper.transferField(srcField,4.57);
 476   CPPUNIT_ASSERT_EQUAL(8,trgField->getArray()->getNumberOfTuples());
 477   CPPUNIT_ASSERT_EQUAL(1,trgField->getArray()->getNumberOfComponents());
 478   const double valuesExpected4[8]={7.,11.,8.,12.,9.,13.,10.,14.};
 479   values=trgField->getArray()->getConstPointer();
 480   for(int i0=0;i0<8;i0++)
 481     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected4[i0],values[i0],1e-12);
 482   trgField->decrRef();
 483   srcField->decrRef();
 484   sourceMesh->decrRef();
 485   targetMesh->decrRef();
 486   // ------------- 1D -> 3D
 487   sourceMesh=MEDCouplingBasicsTest::build1DTargetMesh_1();
 488   targetMesh=MEDCouplingBasicsTest::build3DTargetMesh_1();
 489   remapper.setIntersectionType(INTERP_KERNEL::PointLocator);
 490   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
 491   srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 492   srcField->setNature(ConservativeVolumic);
 493   srcField->setMesh(sourceMesh);
 494   array=DataArrayDouble::New();
 495   array->alloc(sourceMesh->getNumberOfCells(),1);
 496   srcField->setArray(array);
 497   ptr=array->getPointer();
 498   for(int i=0;i<sourceMesh->getNumberOfCells();i++)
 499     ptr[i]=(double)(i+7);
 500   array->decrRef();
 501   trgField=remapper.transferField(srcField,4.57);
 502   CPPUNIT_ASSERT_EQUAL(8,trgField->getArray()->getNumberOfTuples());
 503   CPPUNIT_ASSERT_EQUAL(1,trgField->getArray()->getNumberOfComponents());
 504   const double valuesExpected5[8]={7.,9.,11.,13.,8.,10.,12.,14.};
 505   values=trgField->getArray()->getConstPointer();
 506   for(int i0=0;i0<8;i0++)
 507     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected5[i0],values[i0],1e-12);
 508   trgField->decrRef();
 509   srcField->decrRef();
 510   sourceMesh->decrRef();
 511   targetMesh->decrRef();
 512   // ------------- 2D -> 1D
 513   sourceMesh=MEDCouplingBasicsTest::build2DTargetMesh_1();
 514   targetMesh=build1DTargetMesh_2();
 515   remapper.setIntersectionType(INTERP_KERNEL::PointLocator);
 516   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
 517   srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 518   srcField->setNature(ConservativeVolumic);
 519   srcField->setMesh(sourceMesh);
 520   array=DataArrayDouble::New();
 521   array->alloc(sourceMesh->getNumberOfCells(),1);
 522   srcField->setArray(array);
 523   ptr=array->getPointer();
 524   for(int i=0;i<sourceMesh->getNumberOfCells();i++)
 525     ptr[i]=(double)(i+7);
 526   array->decrRef();
 527   trgField=remapper.transferField(srcField,4.57);
 528   const double valuesExpected8[5]={9.,8.,11.,7.,11.};
 529   values=trgField->getArray()->getConstPointer();
 530   for(int i0=0;i0<5;i0++)
 531     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected8[i0],values[i0],1e-12);
 532   trgField->decrRef();
 533   srcField->decrRef();
 534   sourceMesh->decrRef();
 535   targetMesh->decrRef();
 536   // ------------- 1D -> 2D
 537   sourceMesh=build1DTargetMesh_2();
 538   targetMesh=MEDCouplingBasicsTest::build2DTargetMesh_1();
 539   remapper.setIntersectionType(INTERP_KERNEL::PointLocator);
 540   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
 541   srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 542   srcField->setNature(ConservativeVolumic);
 543   srcField->setMesh(sourceMesh);
 544   array=DataArrayDouble::New();
 545   array->alloc(sourceMesh->getNumberOfCells(),1);
 546   srcField->setArray(array);
 547   ptr=array->getPointer();
 548   for(int i=0;i<sourceMesh->getNumberOfCells();i++)
 549     ptr[i]=(double)(i+7);
 550   array->decrRef();
 551   trgField=remapper.transferField(srcField,4.57);
 552   const double valuesExpected9[5]={10.,8.,7.,4.57,10.};
 553   values=trgField->getArray()->getConstPointer();
 554   for(int i0=0;i0<5;i0++)
 555     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected9[i0],values[i0],1e-12);
 556   trgField->decrRef();
 557   srcField->decrRef();
 558   sourceMesh->decrRef();
 559   targetMesh->decrRef();
 560   // ------------- 2D -> -1D
 561   sourceMesh=MEDCouplingBasicsTest::build2DTargetMesh_1();
 562   targetMesh=MEDCouplingUMesh::New("an example of -1 D mesh",-1);
 563   srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 564   srcField->setNature(ConservativeVolumic);
 565   srcField->setMesh(sourceMesh);
 566   array=DataArrayDouble::New();
 567   array->alloc(sourceMesh->getNumberOfCells(),1);
 568   srcField->setArray(array);
 569   ptr=array->getPointer();
 570   for(int i=0;i<sourceMesh->getNumberOfCells();i++)
 571     ptr[i]=(double)(i+7);
 572   array->decrRef();
 573   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
 574   trgField=remapper.transferField(srcField,4.57);
 575   values=trgField->getArray()->getConstPointer();
 576   CPPUNIT_ASSERT_EQUAL(1,trgField->getNumberOfTuples());
 577   CPPUNIT_ASSERT_EQUAL(1,trgField->getNumberOfComponents());
 578   CPPUNIT_ASSERT_DOUBLES_EQUAL(9.125,values[0],1e-14);
 579   srcField->decrRef();
 580   srcField=remapper.reverseTransferField(trgField,4.220173);
 581   CPPUNIT_ASSERT_EQUAL(5,srcField->getNumberOfTuples());
 582   CPPUNIT_ASSERT_EQUAL(1,srcField->getNumberOfComponents());
 583   values=srcField->getArray()->getConstPointer();
 584   for(int i0=0;i0<5;i0++)
 585     CPPUNIT_ASSERT_DOUBLES_EQUAL(9.125,values[i0],1e-14);
 586   srcField->decrRef();
 587   trgField->setNature(Integral);
 588   srcField=remapper.reverseTransferField(trgField,4.220173);
 589   CPPUNIT_ASSERT_EQUAL(5,srcField->getNumberOfTuples());
 590   CPPUNIT_ASSERT_EQUAL(1,srcField->getNumberOfComponents());
 591   values=srcField->getArray()->getConstPointer();
 592   const double valuesExpected6[5]={2.28125,1.140625,1.140625,2.28125,2.28125};
 593   for(int i0=0;i0<5;i0++)
 594     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected6[i0],values[i0],1e-14);
 595   srcField->decrRef();
 596   trgField->decrRef();
 597   // ------------- -1D -> 2D
 598   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(targetMesh,sourceMesh,"P0P0"));
 599   trgField=MEDCouplingFieldDouble::New(ON_CELLS);
 600   trgField->setNature(ConservativeVolumic);
 601   trgField->setMesh(targetMesh);
 602   array=DataArrayDouble::New();
 603   array->alloc(targetMesh->getNumberOfCells(),1);
 604   trgField->setArray(array);
 605   ptr=array->getPointer();
 606   ptr[0]=7.;
 607   array->decrRef();
 608   srcField=remapper.transferField(trgField,4.221073);
 609   values=srcField->getArray()->getConstPointer();
 610   for(int i0=0;i0<5;i0++)
 611     CPPUNIT_ASSERT_DOUBLES_EQUAL(7.,values[i0],1e-14);
 612   srcField->decrRef();
 613   trgField->setNature(IntegralGlobConstraint);
 614   srcField=remapper.transferField(trgField,4.221073);
 615   values=srcField->getArray()->getConstPointer();
 616   const double valuesExpected7[5]={1.75,0.875,0.875,1.75,1.75};
 617   for(int i0=0;i0<5;i0++)
 618     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected7[i0],values[i0],1e-14);
 619   srcField->decrRef();
 620   trgField->setNature(Integral);
 621   srcField=remapper.transferField(trgField,4.221073);
 622   values=srcField->getArray()->getConstPointer();
 623   for(int i0=0;i0<5;i0++)
 624     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected7[i0],values[i0],1e-14);
 625   srcField->decrRef();
 626   trgField->decrRef();
 627   sourceMesh->decrRef();
 628   targetMesh->decrRef();
 629   //------------- 1D -> 2D
 630   const int conn[8]={0,1,1,2,2,3,3,0};
 631   const int conn2[12]={6,7,5,4,2,7,6,3,0,4,5,1};
 632   const double coords1[]={0.17,0.93,0.56,0.93,0.56,0.25,0.17,0.52};
 633   const double coords2[]={0.,0.,1.,0.,1.,1.,0.,1.,0.,0.5,1.,0.5,0.,0.8,1.,0.8};
 634   sourceMesh=MEDCouplingUMesh::New("src1D",1);
 635   sourceMesh->allocateCells(4);
 636   sourceMesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn);
 637   sourceMesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+2);
 638   sourceMesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+4);
 639   sourceMesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+6);
 640   sourceMesh->finishInsertingCells();
 641   array=DataArrayDouble::New(); array->alloc(4,2);
 642   std::copy(coords1,coords1+8,array->getPointer());
 643   sourceMesh->setCoords(array); array->decrRef();
 644   targetMesh=MEDCouplingUMesh::New("trg2D",2);
 645   targetMesh->allocateCells(3);
 646   targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,conn2);
 647   targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,conn2+4);
 648   targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,conn2+8);
 649   targetMesh->finishInsertingCells();
 650   array=DataArrayDouble::New(); array->alloc(8,2);
 651   std::copy(coords2,coords2+16,array->getPointer());
 652   targetMesh->setCoords(array); array->decrRef();
 653   remapper.setPrecision(1e-12);
 654   remapper.setIntersectionType(INTERP_KERNEL::Geometric2D);
 655   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
 656   srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 657   srcField->setNature(ConservativeVolumic);
 658   srcField->setMesh(sourceMesh);
 659   array=DataArrayDouble::New();
 660   array->alloc(4,1); array->iota(2.);
 661   srcField->setArray(array); array->decrRef();
 662   trgField=remapper.transferField(srcField,4.57);
 663   const double valuesExpected10[3]={3.9674868868103834, 2.8, 3.6372633449255796};
 664   CPPUNIT_ASSERT_EQUAL(3,trgField->getNumberOfTuples());
 665   CPPUNIT_ASSERT_EQUAL(1,trgField->getNumberOfComponents());
 666   for(int i=0;i<3;i++)
 667     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected10[i],trgField->getIJ(i,0),1e-13);
 668   srcField->decrRef();
 669   trgField->decrRef();
 670   //------------- 2D -> 1D
 671   remapper.setPrecision(1e-12);
 672   remapper.setIntersectionType(INTERP_KERNEL::Geometric2D);
 673   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(targetMesh,sourceMesh,"P0P0"));
 674   srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 675   srcField->setNature(ConservativeVolumic);
 676   srcField->setMesh(targetMesh);
 677   array=DataArrayDouble::New();
 678   array->alloc(3,1); array->iota(2.);
 679   srcField->setArray(array); array->decrRef();
 680   trgField=remapper.transferField(srcField,4.57);
 681   const double valuesExpected11[4]={3., 2.9264705882352944, 3.8518518518518516, 2.3170731707317076};
 682   CPPUNIT_ASSERT_EQUAL(4,trgField->getNumberOfTuples());
 683   CPPUNIT_ASSERT_EQUAL(1,trgField->getNumberOfComponents());
 684   for(int i=0;i<4;i++)
 685     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected11[i],trgField->getIJ(i,0),1e-13);
 686   srcField->decrRef();
 687   trgField->decrRef();
 688   sourceMesh->decrRef();
 689   targetMesh->decrRef();
 690   //------------- 2D -> 3D
 691   sourceMesh=MEDCouplingBasicsTest::build3D2DSourceMesh();
 692   targetMesh=MEDCouplingBasicsTest::build3D2DTargetMesh();
 693   remapper.setIntersectionType(INTERP_KERNEL::Triangulation);
 694   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
 695   srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 696   srcField->setNature(ConservativeVolumic);
 697   srcField->setMesh(sourceMesh);
 698   array=DataArrayDouble::New();
 699   array->alloc(7,1); array->iota(2.);
 700   srcField->setArray(array); array->decrRef();
 701   trgField=remapper.transferField(srcField,4.57);
 702   const double valuesExpected12[3]={5.70909090909091, 6.08362715128042, 6.92857142857143};
 703   CPPUNIT_ASSERT_EQUAL(3,trgField->getNumberOfTuples());
 704   CPPUNIT_ASSERT_EQUAL(1,trgField->getNumberOfComponents());
 705   for(int i=0;i<3;i++)
 706     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected12[i],trgField->getIJ(i,0),1e-13);
 707   srcField->decrRef();
 708   trgField->decrRef();
 709   //------------- 3D -> 2D
 710   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(targetMesh,sourceMesh,"P0P0"));
 711   srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 712   srcField->setNature(ConservativeVolumic);
 713   srcField->setMesh(targetMesh);
 714   array=DataArrayDouble::New();
 715   array->alloc(3,1); array->iota(2.);
 716   srcField->setArray(array); array->decrRef();
 717   trgField=remapper.transferField(srcField,4.57);
 718   const double valuesExpected13[7]={3., 4., 2.5, 2.909090909090909, 2., 3.5, 3.3571428571428572};
 719   CPPUNIT_ASSERT_EQUAL(7,trgField->getNumberOfTuples());
 720   CPPUNIT_ASSERT_EQUAL(1,trgField->getNumberOfComponents());
 721   for(int i=0;i<7;i++)
 722     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected13[i],trgField->getIJ(i,0),1e-13);
 723   srcField->decrRef();
 724   trgField->decrRef();
 725   sourceMesh->decrRef();
 726   targetMesh->decrRef();
 727 }
 728
 729 void MEDCouplingRemapperTest::testNatureOfField()
 730 {
 731   MEDCouplingUMesh *sourceMesh=MEDCouplingBasicsTest::build2DSourceMesh_1();
 732   MEDCouplingUMesh *targetMesh=build2DTargetMesh_3();
 733   //
 734   MEDCouplingRemapper remapper;
 735   remapper.setPrecision(1e-12);
 736   remapper.setIntersectionType(INTERP_KERNEL::Triangulation);
 737   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
 738   MEDCouplingFieldDouble *srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 739   srcField->setNature(ConservativeVolumic);
 740   srcField->setMesh(sourceMesh);
 741   DataArrayDouble *array=DataArrayDouble::New();
 742   array->alloc(sourceMesh->getNumberOfCells(),1);
 743   srcField->setArray(array);
 744   double *ptr=array->getPointer();
 745   for(int i=0;i<sourceMesh->getNumberOfCells();i++)
 746     ptr[i]=(double)(i+7);
 747   array->decrRef();
 748   MEDCouplingFieldDouble *trgfield=remapper.transferField(srcField,4.220173);
 749   const double *values=trgfield->getArray()->getConstPointer();
 750   const double valuesExpected[4]={7.75, 7.0625, 4.220173,8.0};
 751   CPPUNIT_ASSERT_EQUAL(4,trgfield->getArray()->getNumberOfTuples());
 752   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 753   for(int i0=0;i0<4;i0++)
 754     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected[i0],values[i0],1e-12);
 755   trgfield->decrRef();
 756   //
 757   srcField->setNature(IntegralGlobConstraint);
 758   trgfield=remapper.transferField(srcField,4.220173);
 759   values=trgfield->getArray()->getConstPointer();
 760   const double valuesExpected2[4]={2.8374999999999999, 7.3624999999999998, 4.220173, 4.7999999999999998};
 761   CPPUNIT_ASSERT_EQUAL(4,trgfield->getArray()->getNumberOfTuples());
 762   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 763   for(int i0=0;i0<4;i0++)
 764     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected2[i0],values[i0],1e-12);
 765   trgfield->decrRef();
 766   //
 767   srcField->setNature(Integral);
 768   trgfield=remapper.transferField(srcField,4.220173);
 769   values=trgfield->getArray()->getConstPointer();
 770   const double valuesExpected3[4]={1.24, 4.5199999999999996, 4.220173, 1.9199999999999999};
 771   CPPUNIT_ASSERT_EQUAL(4,trgfield->getArray()->getNumberOfTuples());
 772   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 773   for(int i0=0;i0<4;i0++)
 774     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected3[i0],values[i0],1e-12);
 775   trgfield->decrRef();
 776   //
 777   srcField->setNature(RevIntegral);
 778   trgfield=remapper.transferField(srcField,4.220173);
 779   values=trgfield->getArray()->getConstPointer();
 780   const double valuesExpected9[4]={2.48, 3.766666666666666, 4.220173, 1.9199999999999999};
 781   CPPUNIT_ASSERT_EQUAL(4,trgfield->getArray()->getNumberOfTuples());
 782   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 783   for(int i0=0;i0<4;i0++)
 784     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected9[i0],values[i0],1e-12);
 785   trgfield->decrRef();
 786   //
 787   srcField->decrRef();
 788   // REVERSE ***********
 789   trgfield=MEDCouplingFieldDouble::New(ON_CELLS);
 790   trgfield->setNature(ConservativeVolumic);
 791   trgfield->setMesh(targetMesh);
 792   array=DataArrayDouble::New();
 793   array->alloc(targetMesh->getNumberOfCells(),1);
 794   trgfield->setArray(array);
 795   ptr=array->getPointer();
 796   for(int i=0;i<targetMesh->getNumberOfCells();i++)
 797     ptr[i]=(double)(i+7);
 798   array->decrRef();
 799   srcField=remapper.reverseTransferField(trgfield,4.220173);
 800   values=srcField->getArray()->getConstPointer();
 801   const double valuesExpected4[2]={7.9375, 8.9};
 802   CPPUNIT_ASSERT_EQUAL(2,srcField->getArray()->getNumberOfTuples());
 803   CPPUNIT_ASSERT_EQUAL(1,srcField->getArray()->getNumberOfComponents());
 804   for(int i0=0;i0<2;i0++)
 805     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected4[i0],values[i0],1e-12);
 806   srcField->decrRef();
 807   //
 808   trgfield->decrRef();
 809   //
 810   sourceMesh->decrRef();
 811   targetMesh->decrRef();
 812   // REVERSE ALL
 813   sourceMesh=build2DTargetMesh_3();
 814   targetMesh=MEDCouplingBasicsTest::build2DSourceMesh_1();
 815   //
 816   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
 817   srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 818   srcField->setNature(ConservativeVolumic);
 819   srcField->setMesh(sourceMesh);
 820   array=DataArrayDouble::New();
 821   array->alloc(sourceMesh->getNumberOfCells(),1);
 822   srcField->setArray(array);
 823   ptr=array->getPointer();
 824   for(int i=0;i<sourceMesh->getNumberOfCells();i++)
 825     ptr[i]=(double)(i+7);
 826   array->decrRef();
 827   trgfield=remapper.transferField(srcField,4.220173);
 828   values=trgfield->getArray()->getConstPointer();
 829   const double valuesExpected5[2]={7.9375, 8.9};
 830   CPPUNIT_ASSERT_EQUAL(2,trgfield->getArray()->getNumberOfTuples());
 831   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 832   for(int i0=0;i0<2;i0++)
 833     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected5[i0],values[i0],1e-12);
 834   trgfield->decrRef();
 835   //
 836   srcField->setNature(IntegralGlobConstraint);
 837   trgfield=remapper.transferField(srcField,4.220173);
 838   values=trgfield->getArray()->getConstPointer();
 839   const double valuesExpected6[4]={9.25, 15.75};
 840   CPPUNIT_ASSERT_EQUAL(2,trgfield->getArray()->getNumberOfTuples());
 841   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 842   for(int i0=0;i0<2;i0++)
 843     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected6[i0],values[i0],1e-12);
 844   trgfield->decrRef();
 845   //
 846   srcField->setNature(Integral);
 847   trgfield=remapper.transferField(srcField,4.220173);
 848   values=trgfield->getArray()->getConstPointer();
 849   const double valuesExpected7[2]={4.56, 4.3466666666666667};
 850   CPPUNIT_ASSERT_EQUAL(2,trgfield->getArray()->getNumberOfTuples());
 851   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 852   for(int i0=0;i0<2;i0++)
 853     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected7[i0],values[i0],1e-12);
 854   trgfield->decrRef();
 855   //
 856   srcField->setNature(RevIntegral);
 857   trgfield=remapper.transferField(srcField,4.220173);
 858   values=trgfield->getArray()->getConstPointer();
 859   const double valuesExpected10[2]={5.08, 3.56};
 860   CPPUNIT_ASSERT_EQUAL(2,trgfield->getArray()->getNumberOfTuples());
 861   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
 862   for(int i0=0;i0<2;i0++)
 863     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected10[i0],values[i0],1e-12);
 864   trgfield->decrRef();
 865   //
 866   srcField->decrRef();
 867   // REVERSE ***********
 868   trgfield=MEDCouplingFieldDouble::New(ON_CELLS);
 869   trgfield->setNature(ConservativeVolumic);
 870   trgfield->setMesh(targetMesh);
 871   array=DataArrayDouble::New();
 872   array->alloc(targetMesh->getNumberOfCells(),1);
 873   trgfield->setArray(array);
 874   ptr=array->getPointer();
 875   for(int i=0;i<targetMesh->getNumberOfCells();i++)
 876     ptr[i]=(double)(i+7);
 877   array->decrRef();
 878   srcField=remapper.reverseTransferField(trgfield,4.220173);
 879   values=srcField->getArray()->getConstPointer();
 880   const double valuesExpected8[4]={7.75, 7.0625,4.220173, 8.0};
 881   CPPUNIT_ASSERT_EQUAL(4,srcField->getArray()->getNumberOfTuples());
 882   CPPUNIT_ASSERT_EQUAL(1,srcField->getArray()->getNumberOfComponents());
 883   for(int i0=0;i0<4;i0++)
 884     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected8[i0],values[i0],1e-12);
 885   srcField->decrRef();
 886   //
 887   trgfield->decrRef();
 888   //
 889   sourceMesh->decrRef();
 890   targetMesh->decrRef();
 891 }
 892
 893 void MEDCouplingRemapperTest::testExtruded()
 894 {
 895   MEDCouplingUMesh *mesh2DS=0;
 896   MEDCouplingUMesh *mesh3DS=build3DExtrudedUMesh_1(mesh2DS);
 897   MEDCouplingExtrudedMesh *extS=MEDCouplingExtrudedMesh::New(mesh3DS,mesh2DS,1);
 898   mesh3DS->decrRef();
 899   mesh2DS->decrRef();
 900   MEDCouplingUMesh *mesh2DT=0;
 901   MEDCouplingUMesh *mesh3DT=build3DExtrudedUMesh_1(mesh2DT);
 902   MEDCouplingExtrudedMesh *extT=MEDCouplingExtrudedMesh::New(mesh3DT,mesh2DT,1);
 903   //
 904   //
 905   mesh3DT->decrRef();
 906   mesh2DT->decrRef();
 907   //
 908   extS->decrRef();
 909   extT->decrRef();
 910 }
 911
 912 void MEDCouplingRemapperTest::testExtruded2()
 913 {
 914   MEDCouplingUMesh *meshN,*meshTT,*meshTF;
 915   MEDCouplingBasicsTest::build3DExtrudedUMesh_2(meshN,meshTT,meshTF);
 916   std::vector<int> n;
 917   double pt[3]={300.,300.,0.};
 918   double v[3]={0.,0.,2.};
 919   meshN->findNodesOnPlane(pt,v,1e-12,n);
 920   MEDCouplingUMesh *meshN2D=(MEDCouplingUMesh *)meshN->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
 921   n.clear();
 922   bool b=false;
 923   int newNbOfNodes;
 924   DataArrayInt *da=meshTT->mergeNodes(1e-12,b,newNbOfNodes);
 925   CPPUNIT_ASSERT(b);
 926   da->decrRef();
 927   meshTT->findNodesOnPlane(pt,v,1e-12,n);
 928   MEDCouplingUMesh *meshTT2D=(MEDCouplingUMesh *)meshTT->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
 929   n.clear();
 930   meshTF->findNodesOnPlane(pt,v,1e-12,n);
 931   MEDCouplingUMesh *meshTF2D=(MEDCouplingUMesh *)meshTF->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
 932   n.clear();
 933   //
 934   MEDCouplingExtrudedMesh *meshNE=MEDCouplingExtrudedMesh::New(meshN,meshN2D,0);
 935   MEDCouplingExtrudedMesh *meshTTE=MEDCouplingExtrudedMesh::New(meshTT,meshTT2D,0);
 936   MEDCouplingExtrudedMesh *meshTFE=MEDCouplingExtrudedMesh::New(meshTF,meshTF2D,0);
 937   //
 938   MEDCouplingRemapper remapper;
 939   remapper.setPrecision(1e-12);
 940   remapper.setIntersectionType(INTERP_KERNEL::Geometric2D);
 941   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(meshNE,meshTTE,"P0P0"));
 942   MEDCouplingFieldDouble *srcField=MEDCouplingFieldDouble::New(ON_CELLS);
 943   srcField->setNature(IntegralGlobConstraint);
 944   srcField->setMesh(meshNE);
 945   DataArrayDouble *array=DataArrayDouble::New();
 946   array->alloc(meshNE->getNumberOfCells(),1);
 947   srcField->setArray(array);
 948   double vals1[40]={
 949     1000.,1000.,1020.,1030.,1040.,1000.,1000.,1070.,1080.,1090.,1000.,1000.,1120.,1130.,1140.,1000.,1000.,1170.,1180.,1190.,
 950     2000.,2000.,2020.,2030.,2040.,2000.,2000.,2070.,2080.,2090.,2000.,2000.,2120.,2130.,2140.,2000.,2000.,2170.,2180.,2190.,
 951   };
 952   CPPUNIT_ASSERT_EQUAL((int)(sizeof(vals1)/sizeof(double)),meshNE->getNumberOfCells());
 953   std::copy(vals1,vals1+meshNE->getNumberOfCells(),array->getPointer());
 954   array->decrRef();
 955   MEDCouplingFieldDouble *trgField=remapper.transferField(srcField,4.220173);
 956   double expected1[200]={
 957     800.,800.,800.,800.,800.,800.,800.,800.,800.,800.,1600.,1600.,1600.,1600.,1600.,1600.,1600.,1600.,1600.,1600.,
 958     102.,102.,102.,102.,102.,102.,102.,102.,102.,102.,202.,202.,202.,202.,202.,202.,202.,202.,202.,202.,
 959     103.,103.,103.,103.,103.,103.,103.,103.,103.,103.,203.,203.,203.,203.,203.,203.,203.,203.,203.,203.,
 960     104.,104.,104.,104.,104.,104.,104.,104.,104.,104.,204.,204.,204.,204.,204.,204.,204.,204.,204.,204.,
 961     219.,219.,219.,219.,219.,219.,219.,219.,219.,219.,419.,419.,419.,419.,419.,419.,419.,419.,419.,419.,
 962     221.,221.,221.,221.,221.,221.,221.,221.,221.,221.,421.,421.,421.,421.,421.,421.,421.,421.,421.,421.,
 963     223.,223.,223.,223.,223.,223.,223.,223.,223.,223.,423.,423.,423.,423.,423.,423.,423.,423.,423.,423.,
 964     117.,117.,117.,117.,117.,117.,117.,117.,117.,117.,217.,217.,217.,217.,217.,217.,217.,217.,217.,217.,
 965     118.,118.,118.,118.,118.,118.,118.,118.,118.,118.,218.,218.,218.,218.,218.,218.,218.,218.,218.,218.,
 966     119.,119.,119.,119.,119.,119.,119.,119.,119.,119.,219.,219.,219.,219.,219.,219.,219.,219.,219.,219.
 967     };
 968   for(int i=0;i<200;i++)
 969     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],trgField->getArray()->getConstPointer()[i],1e-3);//1e-3 precision due to non coincidence in 1D mesh
 970   CPPUNIT_ASSERT_DOUBLES_EQUAL(std::accumulate(expected1,expected1+200,0.),std::accumulate(vals1,vals1+40,0.),1e-10);
 971   CPPUNIT_ASSERT_DOUBLES_EQUAL(std::accumulate(expected1,expected1+200,0.),std::accumulate(trgField->getArray()->getConstPointer(),trgField->getArray()->getConstPointer()+200,0.),1e-10);
 972   trgField->decrRef();
 973   //
 974   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(meshNE,meshTFE,"P0P0"));
 975   trgField=remapper.transferField(srcField,4.220173);
 976   double expected2[340]={25.5, 51.25, 51.75, 26., 79., 158.75, 160.25, 80.5, 85.25, 171.25, 172.75, 86.75, 29.25, 58.75, 59.25, 29.75, 25.5, 51.25, 51.75, 26., 79., 158.75,
 977                          160.25, 80.5, 85.25, 171.25, 172.75, 86.75, 29.25, 58.75, 59.25, 29.75, 25.5, 51.25, 51.75, 26., 79., 158.75, 160.25, 80.5, 85.25, 171.25, 172.75, 86.75,
 978                          29.25, 58.75, 59.25, 29.75, 25.5, 51.25, 51.75, 26., 79., 158.75, 160.25, 80.5, 85.25, 171.25, 172.75, 86.75, 29.25, 58.75, 59.25, 29.75, 25.5, 51.25, 51.75,
 979                          26., 79., 158.75, 160.25, 80.5, 85.25, 171.25, 172.75, 86.75, 29.25, 58.75, 59.25, 29.75, 25.5, 51.25, 51.75, 26., 79., 158.75, 160.25, 80.5, 85.25, 171.25,
 980                          172.75, 86.75, 29.25, 58.75, 59.25, 29.75, 25.5, 51.25, 51.75, 26., 79., 158.75, 160.25, 80.5, 85.25, 171.25, 172.75, 86.75, 29.25, 58.75, 59.25, 29.75, 25.5,
 981                          51.25, 51.75, 26., 79., 158.75, 160.25, 80.5, 85.25, 171.25, 172.75, 86.75, 29.25, 58.75, 59.25, 29.75, 25.5, 51.25, 51.75, 26., 79., 158.75, 160.25, 80.5,
 982                          85.25, 171.25, 172.75, 86.75, 29.25, 58.75, 59.25, 29.75, 25.5, 51.25, 51.75, 26., 79., 158.75, 160.25, 80.5, 85.25, 171.25, 172.75, 86.75, 29.25, 58.75, 59.25,
 983                          29.75, 50.5, 101.25, 101.75, 51., 154., 308.75, 310.25, 155.5, 160.25, 321.25, 322.75, 161.75, 54.25, 108.75, 109.25, 54.75, 50.5, 101.25, 101.75, 51., 154.,
 984                          308.75, 310.25, 155.5, 160.25, 321.25, 322.75, 161.75, 54.25, 108.75, 109.25, 54.75, 50.5, 101.25, 101.75, 51., 154., 308.75, 310.25, 155.5, 160.25, 321.25, 322.75,
 985                          161.75, 54.25, 108.75, 109.25, 54.75, 50.5, 101.25, 101.75, 51., 154., 308.75, 310.25, 155.5, 160.25, 321.25, 322.75, 161.75, 54.25, 108.75, 109.25, 54.75, 50.5,
 986                          101.25, 101.75, 51., 154., 308.75, 310.25, 155.5, 160.25, 321.25, 322.75, 161.75, 54.25, 108.75, 109.25, 54.75, 50.5, 101.25, 101.75, 51., 154., 308.75, 310.25,
 987                          155.5, 160.25, 321.25, 322.75, 161.75, 54.25, 108.75, 109.25, 54.75, 50.5, 101.25, 101.75, 51., 154., 308.75, 310.25, 155.5, 160.25, 321.25, 322.75, 161.75, 54.25,
 988                          108.75, 109.25, 54.75, 50.5, 101.25, 101.75, 51., 154., 308.75, 310.25, 155.5, 160.25, 321.25, 322.75, 161.75, 54.25, 108.75, 109.25, 54.75, 50.5, 101.25, 101.75,
 989                          51., 154., 308.75, 310.25, 155.5, 160.25, 321.25, 322.75, 161.75, 54.25, 108.75, 109.25, 54.75, 50.5, 101.25, 101.75, 51., 154., 308.75, 310.25, 155.5, 160.25, 321.25,
 990                          322.75, 161.75, 54.25, 108.75, 109.25, 54.75, 800., 800., 800., 800., 800., 800., 800., 800., 800., 800., 1600., 1600., 1600., 1600., 1600., 1600., 1600.,
 991                          1600., 1600., 1600.};
 992   for(int i=0;i<340;i++)
 993     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],trgField->getArray()->getConstPointer()[i],1e-3);//1e-3 precision due to non coincidence in 1D mesh
 994   CPPUNIT_ASSERT_DOUBLES_EQUAL(std::accumulate(expected2,expected2+340,0.),std::accumulate(vals1,vals1+40,0.),1e-10);
 995   CPPUNIT_ASSERT_DOUBLES_EQUAL(std::accumulate(expected2,expected2+340,0.),std::accumulate(trgField->getArray()->getConstPointer(),trgField->getArray()->getConstPointer()+340,0.),1e-10);
 996   trgField->decrRef();
 997   srcField->decrRef();
 998   //
 999   double vals2[200]={
1000     100., 200., 300., 400., 500., 600., 700., 800., 900., 1000., 1100., 1200., 1300., 1400., 1500., 1600., 1700., 1800., 1900., 2000,
1001     101., 201., 301., 401., 501., 601., 701., 801., 901., 1001., 1101., 1201., 1301., 1401., 1501., 1601., 1701., 1801., 1901., 2001,
1002     102., 202., 302., 402., 502., 602., 702., 802., 902., 1002., 1102., 1202., 1302., 1402., 1502., 1602., 1702., 1802., 1902., 2002,
1003     103., 203., 303., 403., 503., 603., 703., 803., 903., 1003., 1103., 1203., 1303., 1403., 1503., 1603., 1703., 1803., 1903., 2003,
1004     104., 204., 304., 404., 504., 604., 704., 804., 904., 1004., 1104., 1204., 1304., 1404., 1504., 1604., 1704., 1804., 1904., 2004,
1005     105., 205., 305., 405., 505., 605., 705., 805., 905., 1005., 1105., 1205., 1305., 1405., 1505., 1605., 1705., 1805., 1905., 2005,
1006     106., 206., 306., 406., 506., 606., 706., 806., 906., 1006., 1106., 1206., 1306., 1406., 1506., 1606., 1706., 1806., 1906., 2006,
1007     107., 207., 307., 407., 507., 607., 707., 807., 907., 1007., 1107., 1207., 1307., 1407., 1507., 1607., 1707., 1807., 1907., 2007,
1008     108., 208., 308., 408., 508., 608., 708., 808., 908., 1008., 1108., 1208., 1308., 1408., 1508., 1608., 1708., 1808., 1908., 2008,
1009     109., 209., 309., 409., 509., 609., 709., 809., 909., 1009., 1109., 1209., 1309., 1409., 1509., 1609., 1709., 1809., 1909., 2009.
1010   };
1011   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(meshNE,meshTTE,"P0P0"));
1012   trgField=MEDCouplingFieldDouble::New(ON_CELLS);
1013   trgField->setNature(ConservativeVolumic);
1014   trgField->setMesh(meshTTE);
1015   array=DataArrayDouble::New();
1016   array->alloc(meshTTE->getNumberOfCells(),1);
1017   trgField->setArray(array);
1018   std::copy(vals2,vals2+meshTTE->getNumberOfCells(),array->getPointer());
1019   array->decrRef();
1020   srcField=remapper.reverseTransferField(trgField,4.220173);
1021   double expected3[40]={
1022     550.,550.,551.,552.,553.,550.,550.,554.,555.,556.,550.,550.,554.,555.,556.,550.,550.,557.,558.,559.,
1023     1550.,1550.,1551.,1552.,1553.,1550.,1550.,1554.,1555.,1556.,1550.,1550.,1554.,1555.,1556.,1550.,1550.,1557.,1558.,1559.
1024   };
1025   for(int i=0;i<40;i++)
1026     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[i],srcField->getArray()->getConstPointer()[i],1e-3);//1e-3 precision due to non coincidence in 1D mesh
1027   srcField->decrRef();
1028   trgField->decrRef();
1029   //
1030   double vals3[340]={
1031     100., 101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112., 113., 114., 115.,
1032     200., 201., 202., 203., 204., 205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215.,
1033     300., 301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312., 313., 314., 315.,
1034     400., 401., 402., 403., 404., 405., 406., 407., 408., 409., 410., 411., 412., 413., 414., 415.,
1035     500., 501., 502., 503., 504., 505., 506., 507., 508., 509., 510., 511., 512., 513., 514., 515.,
1036     600., 601., 602., 603., 604., 605., 606., 607., 608., 609., 610., 611., 612., 613., 614., 615.,
1037     700., 701., 702., 703., 704., 705., 706., 707., 708., 709., 710., 711., 712., 713., 714., 715.,
1038     800., 801., 802., 803., 804., 805., 806., 807., 808., 809., 810., 811., 812., 813., 814., 815.,
1039     900., 901., 902., 903., 904., 905., 906., 907., 908., 909., 910., 911., 912., 913., 914., 915.,
1040     1000., 1001., 1002., 1003., 1004., 1005., 1006., 1007., 1008., 1009., 1010., 1011., 1012., 1013., 1014., 1015.,
1041     1100., 1101., 1102., 1103., 1104., 1105., 1106., 1107., 1108., 1109., 1110., 1111., 1112., 1113., 1114., 1115.,
1042     1200., 1201., 1202., 1203., 1204., 1205., 1206., 1207., 1208., 1209., 1210., 1211., 1212., 1213., 1214., 1215.,
1043     1300., 1301., 1302., 1303., 1304., 1305., 1306., 1307., 1308., 1309., 1310., 1311., 1312., 1313., 1314., 1315.,
1044     1400., 1401., 1402., 1403., 1404., 1405., 1406., 1407., 1408., 1409., 1410., 1411., 1412., 1413., 1414., 1415.,
1045     1500., 1501., 1502., 1503., 1504., 1505., 1506., 1507., 1508., 1509., 1510., 1511., 1512., 1513., 1514., 1515.,
1046     1600., 1601., 1602., 1603., 1604., 1605., 1606., 1607., 1608., 1609., 1610., 1611., 1612., 1613., 1614., 1615.,
1047     1700., 1701., 1702., 1703., 1704., 1705., 1706., 1707., 1708., 1709., 1710., 1711., 1712., 1713., 1714., 1715.,
1048     1800., 1801., 1802., 1803., 1804., 1805., 1806., 1807., 1808., 1809., 1810., 1811., 1812., 1813., 1814., 1815.,
1049     1900., 1901., 1902., 1903., 1904., 1905., 1906., 1907., 1908., 1909., 1910., 1911., 1912., 1913., 1914., 1915.,
1050     2000., 2001., 2002., 2003., 2004., 2005., 2006., 2007., 2008., 2009., 2010., 2011., 2012., 2013., 2014., 2015.,
1051     116.,216.,316.,416.,516.,616.,716.,816.,916.,1016.,1116.,1216.,1316.,1416.,1516.,1616.,1716.,1816.,1916.,2016.
1052   };
1053   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(meshNE,meshTFE,"P0P0"));
1054   trgField=MEDCouplingFieldDouble::New(ON_CELLS);
1055   trgField->setNature(ConservativeVolumic);
1056   trgField->setMesh(meshTFE);
1057   array=DataArrayDouble::New();
1058   array->alloc(meshTFE->getNumberOfCells(),1);
1059   trgField->setArray(array);
1060   std::copy(vals3,vals3+meshTFE->getNumberOfCells(),array->getPointer());
1061   array->decrRef();
1062   srcField=remapper.reverseTransferField(trgField,4.220173);
1063   double expected4[40]={
1064     566.,566.,552.5,553.5,554.5,566.,566.,554.5,555.5,556.5,566.,566.,558.5,559.5,560.5,566.,566.,560.5,561.5,562.5,
1065     1566.,1566.,1552.5,1553.5,1554.5,1566.,1566.,1554.5,1555.5,1556.5,1566.,1566.,1558.5,1559.5,1560.5,1566.,1566.,1560.5,1561.5,1562.5
1066   };
1067   for(int i=0;i<40;i++)
1068     CPPUNIT_ASSERT_DOUBLES_EQUAL(expected4[i],srcField->getArray()->getConstPointer()[i],1e-3);//1e-3 precision due to non coincidence in 1D mesh
1069   srcField->decrRef();
1070   trgField->decrRef();
1071   //
1072   meshN2D->decrRef();
1073   meshTT2D->decrRef();
1074   meshTF2D->decrRef();
1075   meshNE->decrRef();
1076   meshTTE->decrRef();
1077   meshTFE->decrRef();
1078   meshN->decrRef();
1079   meshTT->decrRef();
1080   meshTF->decrRef();
1081 }
1082
1083 void MEDCouplingRemapperTest::testPrepareEx1()
1084 {
1085   MEDCouplingUMesh *sourceMesh=MEDCouplingBasicsTest::build2DSourceMesh_1();
1086   MEDCouplingUMesh *targetMesh=build2DTargetMesh_3();
1087   //
1088   MEDCouplingRemapper remapper;
1089   remapper.setPrecision(1e-12);
1090   remapper.setIntersectionType(INTERP_KERNEL::Triangulation);
1091   MEDCouplingFieldTemplate *srcFt=MEDCouplingFieldTemplate::New(ON_CELLS);
1092   MEDCouplingFieldTemplate *trgFt=MEDCouplingFieldTemplate::New(ON_CELLS);
1093   srcFt->setMesh(sourceMesh);
1094   trgFt->setMesh(targetMesh);
1095   CPPUNIT_ASSERT_EQUAL(1,remapper.prepareEx(srcFt,trgFt));
1096   srcFt->decrRef();
1097   trgFt->decrRef();
1098   MEDCouplingFieldDouble *srcField=MEDCouplingFieldDouble::New(ON_CELLS);
1099   srcField->setNature(ConservativeVolumic);
1100   srcField->setMesh(sourceMesh);
1101   DataArrayDouble *array=DataArrayDouble::New();
1102   array->alloc(sourceMesh->getNumberOfCells(),1);
1103   srcField->setArray(array);
1104   double *ptr=array->getPointer();
1105   for(int i=0;i<sourceMesh->getNumberOfCells();i++)
1106     ptr[i]=(double)(i+7);
1107   array->decrRef();
1108   MEDCouplingFieldDouble *trgfield=remapper.transferField(srcField,4.220173);
1109   const double *values=trgfield->getArray()->getConstPointer();
1110   const double valuesExpected[4]={7.75, 7.0625, 4.220173,8.0};
1111   CPPUNIT_ASSERT_EQUAL(4,trgfield->getArray()->getNumberOfTuples());
1112   CPPUNIT_ASSERT_EQUAL(1,trgfield->getArray()->getNumberOfComponents());
1113   for(int i0=0;i0<4;i0++)
1114     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected[i0],values[i0],1e-12);
1115   trgfield->decrRef();
1116   srcField->decrRef();
1117   sourceMesh->decrRef();
1118   targetMesh->decrRef();
1119 }
1120
1121 MEDCouplingUMesh *MEDCouplingRemapperTest::build1DTargetMesh_2()
1122 {
1123   double targetCoords[20]={
1124     0.59,0.09, 0.69,0.19, 0.21,-0.29,0.31,-0.19, 0.45,0.25,0.65,0.45,
1125     -0.2,-0.2,0.11,0.11, 0.25,0.25, 0.45,0.45
1126   };
1127   int targetConn[10]={0,1, 2,3, 4,5, 6,7, 8,9};
1128
1129   MEDCouplingUMesh *targetMesh=MEDCouplingUMesh::New("my name of mesh 1D 2",1);
1130   targetMesh->allocateCells(5);
1131   for(int i=0;i<5;i++)
1132     targetMesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,targetConn+2*i);
1133   targetMesh->finishInsertingCells();
1134   DataArrayDouble *myCoords=DataArrayDouble::New();
1135   myCoords->alloc(10,2);
1136   std::copy(targetCoords,targetCoords+20,myCoords->getPointer());
1137   targetMesh->setCoords(myCoords);
1138   myCoords->decrRef();
1139   return targetMesh;
1140 }
1141
1142 MEDCouplingUMesh *MEDCouplingRemapperTest::build2DTargetMesh_3()
1143 {
1144   double targetCoords[20]={-0.6,-0.4, -0.1,-0.4, 1.1,-0.4, 2.1,-0.4,
1145                            -0.6,0.1,  -0.1,0.1,  1.1,0.1,  2.1,0.1,
1146                            -0.6,1.1,  -0.1,1.1};
1147   int targetConn[16]={0,4,5,1, 1,5,6,2, 2,6,7,3, 4,8,9,5};
1148   MEDCouplingUMesh *targetMesh=MEDCouplingUMesh::New();
1149   targetMesh->setMeshDimension(2);
1150   targetMesh->allocateCells(4);
1151   for(int i=0;i<4;i++)
1152     targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+4*i);
1153   targetMesh->finishInsertingCells();
1154   DataArrayDouble *myCoords=DataArrayDouble::New();
1155   myCoords->alloc(10,2);
1156   std::copy(targetCoords,targetCoords+20,myCoords->getPointer());
1157   targetMesh->setCoords(myCoords);
1158   myCoords->decrRef();
1159   return targetMesh;
1160 }
1161
1162 MEDCouplingUMesh *MEDCouplingRemapperTest::build3DExtrudedUMesh_1(MEDCouplingUMesh *&mesh2D)
1163 {
1164   double coords[180]={
1165     0.,0.,0., 1.,1.,0., 1.,1.25,0., 0.,1.,0., 1.,1.5,0., 2.,0.,0., 2.,1.,0., 1.,2.,0., 0.,2.,0., 3.,1.,0.,
1166     3.,2.,0., 0.,1.,0., 1.,3.,0., 2.,2.,0., 2.,3.,0.,
1167     0.,0.,1., 1.,1.,1., 1.,1.25,1., 0.,1.,1., 1.,1.5,1., 2.,0.,1., 2.,1.,1., 1.,2.,1., 0.,2.,1., 3.,1.,1.,
1168     3.,2.,1., 0.,1.,1., 1.,3.,1., 2.,2.,1., 2.,3.,1.,
1169     0.,0.,2., 1.,1.,2., 1.,1.25,2., 0.,1.,2., 1.,1.5,2., 2.,0.,2., 2.,1.,2., 1.,2.,2., 0.,2.,2., 3.,1.,2.,
1170     3.,2.,2., 0.,1.,2., 1.,3.,2., 2.,2.,2., 2.,3.,2.,
1171     0.,0.,3., 1.,1.,3., 1.,1.25,3., 0.,1.,3., 1.,1.5,3., 2.,0.,3., 2.,1.,3., 1.,2.,3., 0.,2.,3., 3.,1.,3.,
1172     3.,2.,3., 0.,1.,3., 1.,3.,3., 2.,2.,3., 2.,3.,3.};
1173
1174   int conn[354]={
1175     // 0
1176     0,11,1,3,15,26,16,18,   1,2,4,7,13,6,-1,1,16,21,6,-1,6,21,28,13,-1,13,7,22,28,-1,7,4,19,22,-1,4,2,17,19,-1,2,1,16,17,-1,16,21,28,22,19,17,
1177     1,6,5,3,16,21,20,18,   13,10,9,6,28,25,24,21,
1178     11,8,7,4,2,1,-1,11,26,16,1,-1,1,16,17,2,-1,2,17,19,4,-1,4,19,22,7,-1,7,8,23,22,-1,8,11,26,23,-1,26,16,17,19,22,23,
1179     7,12,14,13,22,27,29,28,
1180     // 1
1181     15,26,16,18,30,41,31,33,   16,17,19,22,28,21,-1,16,31,36,21,-1,21,36,43,28,-1,28,22,37,43,-1,22,19,34,37,-1,19,17,32,34,-1,17,16,31,32,-1,31,36,43,37,34,32,
1182     16,21,20,18,31,36,35,33,   28,25,24,21,43,40,39,36,
1183     26,23,22,19,17,16,-1,26,41,31,16,-1,16,31,32,17,-1,17,32,34,19,-1,19,34,37,22,-1,22,23,38,37,-1,23,26,41,38,-1,41,31,32,34,37,38,
1184     22,27,29,28,37,42,44,43,
1185     // 2
1186     30,41,31,33,45,56,46,48,  31,32,34,37,43,36,-1,31,46,51,36,-1,36,51,58,43,-1,43,37,52,58,-1,37,34,49,52,-1,34,32,47,49,-1,32,31,46,47,-1,46,51,58,52,49,47,
1187     31,36,35,33,46,51,50,48,  43,40,39,36,58,55,54,51,
1188     41,38,37,34,32,31,-1,41,56,46,31,-1,31,46,47,32,-1,32,47,49,34,-1,34,49,52,37,-1,37,38,53,52,-1,38,41,56,53,-1,56,46,47,49,52,53,
1189     37,42,44,43,52,57,59,58
1190   };
1191   int conn2[28]={7,12,14,13, 11,8,7,4,2,1, 13,10,9,6, 1,6,5,3, 1,2,4,7,13,6, 0,11,1,3};
1192   //
1193   MEDCouplingUMesh *ret=MEDCouplingUMesh::New();
1194   ret->setMeshDimension(3);
1195   ret->allocateCells(18);
1196   //
1197   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn);
1198   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+8);
1199   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+51);
1200   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+59);
1201   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+67);
1202   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+110);
1203   //
1204   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+118);
1205   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+126);
1206   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+169);
1207   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+177);
1208   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+185);
1209   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+228);
1210   //
1211   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+236);
1212   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+244);
1213   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+287);
1214   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+295);
1215   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+303);
1216   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+346);
1217   //
1218   ret->finishInsertingCells();
1219   DataArrayDouble *myCoords=DataArrayDouble::New();
1220   myCoords->alloc(60,3);
1221   std::copy(coords,coords+180,myCoords->getPointer());
1222   ret->setCoords(myCoords);
1223   //
1224   mesh2D=MEDCouplingUMesh::New();
1225   mesh2D->setMeshDimension(2);
1226   mesh2D->allocateCells(6);
1227   mesh2D->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,conn2);
1228   mesh2D->insertNextCell(INTERP_KERNEL::NORM_POLYGON,6,conn2+4);
1229   mesh2D->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,conn2+10);
1230   mesh2D->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,conn2+14);
1231   mesh2D->insertNextCell(INTERP_KERNEL::NORM_POLYGON,6,conn2+18);
1232   mesh2D->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,conn2+24);
1233   mesh2D->setCoords(myCoords);
1234   myCoords->decrRef();
1235   return ret;
1236 }
1237
1238 void MEDCouplingRemapperTest::testPartialTransfer1()
1239 {
1240   MEDCouplingRemapper remapper;
1241   MEDCouplingUMesh *sourceMesh=build1DTargetMesh_2();
1242   MEDCouplingUMesh *targetMesh=MEDCouplingBasicsTest::build2DTargetMesh_1();
1243   remapper.setIntersectionType(INTERP_KERNEL::PointLocator);
1244   CPPUNIT_ASSERT_EQUAL(1,remapper.prepare(sourceMesh,targetMesh,"P0P0"));
1245   MEDCouplingFieldDouble *srcField=MEDCouplingFieldDouble::New(ON_CELLS);
1246   srcField->setNature(ConservativeVolumic);
1247   srcField->setMesh(sourceMesh);
1248   DataArrayDouble *array=DataArrayDouble::New();
1249   array->alloc(sourceMesh->getNumberOfCells(),1);
1250   srcField->setArray(array);
1251   double *ptr=array->getPointer();
1252   for(int i=0;i<sourceMesh->getNumberOfCells();i++)
1253     ptr[i]=(double)(i+7);
1254   array->decrRef();
1255   MEDCouplingFieldDouble *trgField=MEDCouplingFieldDouble::New(ON_CELLS);
1256   trgField->setNature(ConservativeVolumic);
1257   trgField->setMesh(targetMesh);
1258   array=DataArrayDouble::New();
1259   array->alloc(targetMesh->getNumberOfCells(),1);
1260   ptr=array->getPointer();
1261   std::fill(ptr,ptr+targetMesh->getNumberOfCells(),96.3);
1262   trgField->setArray(array);
1263   array->decrRef();
1264   remapper.partialTransfer(srcField,trgField);
1265   const double valuesExpected9[5]={10.,8.,7.,96.3,10.};
1266   const double *values=trgField->getArray()->getConstPointer();
1267   for(int i0=0;i0<5;i0++)
1268     CPPUNIT_ASSERT_DOUBLES_EQUAL(valuesExpected9[i0],values[i0],1e-12);
1269   trgField->decrRef();
1270   srcField->decrRef();
1271   sourceMesh->decrRef();
1272   targetMesh->decrRef();
1273 }