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