src/MEDMEMCppTest/MEDMEMTest_Connectivity.cxx

   1 // Copyright (C) 2007-2013  CEA/DEN, EDF R&D, OPEN CASCADE
   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 "MEDMEMTest.hxx"
  21 #include <cppunit/TestAssert.h>
  22
  23 #include "MEDMEM_Connectivity.hxx"
  24 #include "MEDMEM_define.hxx"
  25 #include "MEDMEM_MedMeshDriver.hxx"
  26 #include "MEDMEM_Mesh.hxx"
  27 #include "MEDMEM_Family.hxx"
  28
  29 #include <sstream>
  30 #include <cmath>
  31
  32 // use this define to enable lines, execution of which leads to Segmentation Fault
  33 //#define ENABLE_FAULTS
  34
  35 // use this define to enable CPPUNIT asserts and fails, showing bugs
  36 //#define ENABLE_FORCED_FAILURES
  37
  38 using namespace std;
  39 using namespace MEDMEM;
  40
  41 // #7: MEDMEM_Connectivity.hxx  }  MEDMEMTest_Connectivity.cxx
  42
  43 /*!
  44  *  Check methods (56), defined in MEDMEM_Connectivity.hxx:
  45  *  class CONNECTIVITY {
  46  *   (+)     friend ostream & operator<<(ostream &os, CONNECTIVITY &connectivity);
  47  *   (+)     CONNECTIVITY (MED_EN::medEntityMesh Entity=MED_EN::MED_CELL);
  48  *   (+)     CONNECTIVITY (int numberOfTypes, MED_EN::medEntityMesh Entity=MED_EN::MED_CELL);
  49  *   (+)     CONNECTIVITY (const CONNECTIVITY & m);
  50  *   (+)     virtual ~CONNECTIVITY ();
  51  *   (+)     void setConstituent (CONNECTIVITY * Constituent) throw (MEDEXCEPTION);
  52  *   (+)     void setGeometricTypes (const MED_EN::medGeometryElement * Types,
  53  *                                   const MED_EN::medEntityMesh Entity) throw (MEDEXCEPTION);
  54  *   (+)     void setCount (const int * Count, const MED_EN::medEntityMesh Entity) throw (MEDEXCEPTION);
  55  *   (+)     void setNodal (const int * Connectivity,
  56  *                          const MED_EN::medEntityMesh Entity,
  57  *                          const MED_EN::medGeometryElement Type,
  58  *                          const int * PolyConnectivityIndex=0) throw (MEDEXCEPTION);
  59  *   (+)     inline void setNumberOfNodes(int NumberOfNodes);
  60  *   (+)     inline int getEntityDimension() const;
  61  *   (+)     inline void setEntityDimension(int EntityDimension);
  62  *   -----------------------------------------------------------------------------------------------------
  63  *   (+)     inline bool existConnectivity (MED_EN::medConnectivity connectivityType,
  64  *                                          MED_EN::medEntityMesh Entity) const;
  65  *   (+)     virtual void calculateConnectivity (MED_EN::medConnectivity connectivityType,
  66  *                                               MED_EN::medEntityMesh Entity);
  67  *   (?)     virtual void updateFamily (const vector<FAMILY*>& myFamilies);
  68  *
  69  *   (+)     inline MED_EN::medEntityMesh getEntity() const;
  70  *   -----------------------------------------------------------------------------------------------------
  71  *   (+)     inline int getNumberOfTypes (MED_EN::medEntityMesh Entity) const;
  72  *   (+)     inline const MED_EN::medGeometryElement * getGeometricTypes
  73  *                        (MED_EN::medEntityMesh Entity) const throw (MEDEXCEPTION);
  74  *   (+)     MED_EN::medGeometryElement getElementType (MED_EN::medEntityMesh Entity, int Number) const;
  75  *   (+)     inline MED_EN::medGeometryElement getPolyTypeRelativeTo() const;
  76  *   -----------------------------------------------------------------------------------------------------
  77  *   (+)     virtual inline const int * getGlobalNumberingIndex
  78  *                        (MED_EN::medEntityMesh Entity) const throw (MEDEXCEPTION);
  79  *   -----------------------------------------------------------------------------------------------------
  80  *   (+)     virtual const int * getConnectivity (MED_EN::medConnectivity ConnectivityType,
  81  *                                                MED_EN::medEntityMesh Entity,
  82  *                                                MED_EN::medGeometryElement Type);
  83  *   (+)     virtual int getConnectivityLength (MED_EN::medConnectivity ConnectivityType,
  84  *                                              MED_EN::medEntityMesh Entity,
  85  *                                              MED_EN::medGeometryElement Type);
  86  *   (+)     virtual const int * getConnectivityIndex (MED_EN::medConnectivity ConnectivityType,
  87  *                                                     MED_EN::medEntityMesh Entity);
  88  *   (+)     int *getNodesOfPolyhedron(int polyhedronId, int& lgthOfTab) const;
  89  *   (+)     int **getNodesPerFaceOfPolyhedron(int polyhedronId, int& nbOfFaces,
  90  *                                             int* & nbOfNodesPerFaces) const;
  91  *   -----------------------------------------------------------------------------------------------------
  92  *   (+)     const CELLMODEL & getType (MED_EN::medGeometryElement Type) const;
  93  *   (+)     const CELLMODEL * getCellsTypes (MED_EN::medEntityMesh Entity) const throw (MEDEXCEPTION);
  94  *   (+)     string * getCellTypeNames (MED_EN::medEntityMesh Entity) const throw (MEDEXCEPTION);
  95  *   (+)     int getNumberOfNodesInType (MED_EN::medGeometryElement Type) const;
  96  *   (+)     int getNumberOfSubCellInType (MED_EN::medGeometryElement Type) const;
  97  *   -----------------------------------------------------------------------------------------------------
  98  *   (+)     virtual int getNumberOf (MED_EN::medEntityMesh Entity, MED_EN::medGeometryElement Type) const;
  99  *   -----------------------------------------------------------------------------------------------------
 100  *   (+)     virtual const int* getValue (MED_EN::medConnectivity TypeConnectivity,
 101  *                                        MED_EN::medGeometryElement Type);
 102  *   (+)     virtual const int* getValueIndex (MED_EN::medConnectivity TypeConnectivity);
 103  *   -----------------------------------------------------------------------------------------------------
 104  *   (+)     virtual inline const int* getReverseConnectivity (MED_EN::medConnectivity ConnectivityType,
 105  *                                        MED_EN::medEntityMesh Entity=MED_EN::MED_CELL) throw (MEDEXCEPTION);
 106  *   (+)     virtual inline const int* getReverseConnectivityIndex (MED_EN::medConnectivity ConnectivityType,
 107  *                                        MED_EN::medEntityMesh Entity=MED_EN::MED_CELL) throw (MEDEXCEPTION);
 108  *   (NOT YET IMPLEMENTED!!!) const int* getNeighbourhood() const;
 109  *   (+)     void invertConnectivityForAFace(int faceId, const int *nodalConnForFace);
 110  *   -----------------------------------------------------------------------------------------------------
 111  *   (+)     bool deepCompare(const CONNECTIVITY& other) const;
 112  *
 113  *  Use code of MEDMEM/test_copie_connectivity.cxx
 114  *  }
 115  */
 116 static void checkConnectivity(CONNECTIVITY * myConnectivity,
 117                               int MeshDimension, int NumberOfNodes,
 118                               MED_EN::medEntityMesh Entity,
 119                               int NumberOfTypes)
 120 {
 121   int entityDim = myConnectivity->getEntityDimension();
 122   CPPUNIT_ASSERT_EQUAL(MeshDimension, entityDim);
 123
 124   int nodesNb = myConnectivity->getNumberOf(MED_EN::MED_NODE, MED_EN::MED_NONE);
 125   CPPUNIT_ASSERT_EQUAL(NumberOfNodes, nodesNb); //?
 126
 127   // MED_EN::MED_CELL
 128   MED_EN::medEntityMesh entity = myConnectivity->getEntity();
 129   CPPUNIT_ASSERT_EQUAL(Entity, entity);
 130
 131   int typesNb = myConnectivity->getNumberOfTypes(Entity);
 132   CPPUNIT_ASSERT_EQUAL(NumberOfTypes, typesNb);
 133
 134   const MED_EN::medGeometryElement * Types = myConnectivity->getGeometricTypes(Entity);
 135   CPPUNIT_ASSERT( Types );
 136
 137   // TODO: implement some more checks
 138   int NumberOfElements;
 139   const int * connectivity;
 140   const int * connectivity_index;
 141   myConnectivity->calculateConnectivity(MED_EN::MED_DESCENDING, Entity);
 142   try {
 143     NumberOfElements = myConnectivity->getNumberOf(Entity, MED_EN::MED_ALL_ELEMENTS);
 144     connectivity = myConnectivity->getConnectivity(MED_EN::MED_DESCENDING, Entity,
 145                                                    MED_EN::MED_ALL_ELEMENTS);
 146     connectivity_index = myConnectivity->getConnectivityIndex(MED_EN::MED_DESCENDING, Entity);
 147   }
 148   catch (MEDEXCEPTION m) {
 149     CPPUNIT_FAIL(m.what());
 150   }
 151
 152   // Get constituent entity type and quantity
 153   int NumberOfConstituents  = 0;
 154   string constituent;
 155   MED_EN::medEntityMesh constituentEntity;
 156
 157   if (MeshDimension == 3) {
 158     constituent = "Face";
 159     constituentEntity = MED_EN::MED_FACE;
 160   }
 161
 162   if (MeshDimension == 2) {
 163     constituent = "Edge";
 164     constituentEntity = MED_EN::MED_EDGE;
 165   }
 166
 167   if (MeshDimension == 1) {
 168     MESSAGE_MED("ERROR : MeshDimension = 1 !");
 169     MESSAGE_MED("We could not see Reverse Descending Connectivity.");
 170     return;
 171   }
 172
 173   myConnectivity->getReverseConnectivity(MED_EN::MED_DESCENDING, Entity);
 174   myConnectivity->getReverseConnectivityIndex(MED_EN::MED_DESCENDING, Entity);
 175
 176   NumberOfConstituents = myConnectivity->getNumberOf(constituentEntity, MED_EN::MED_ALL_ELEMENTS);
 177   myConnectivity->getConnectivity(MED_EN::MED_NODAL, constituentEntity, MED_EN::MED_ALL_ELEMENTS);
 178   myConnectivity->getConnectivityIndex(MED_EN::MED_NODAL, constituentEntity);
 179 }
 180
 181 /////////////////////////////////////////
 182 // TEST 2: test_copie_connectivity.cxx //
 183 /////////////////////////////////////////
 184 static void checkCopyConnectivity()
 185 {
 186   string filename = getResourceFile("pointe.med");
 187   string meshname = "maa1";
 188
 189   //Construction d'un maillage
 190   MESH * myMesh = new MESH;
 191   myMesh->setName(meshname);
 192   MED_MESH_RDONLY_DRIVER myMeshDriver (filename, myMesh);
 193   myMeshDriver.setMeshName(meshname);
 194   myMeshDriver.open();
 195   myMeshDriver.read(); //A partir d'ici la connectivité est construite
 196   myMeshDriver.close();
 197
 198   int aMeshDimension = myMesh->getMeshDimension();
 199   int aNumberOfNodes = myMesh->getNumberOfNodes();
 200
 201   const CONNECTIVITY * myConnectivity0 = myMesh->getConnectivityptr();
 202   CONNECTIVITY * myConnectivity1 = const_cast<CONNECTIVITY *>(myConnectivity0);
 203
 204   // DATA:
 205   MED_EN::medEntityMesh anEntity0 = myConnectivity0->getEntity();
 206
 207   int nbOfTypes = myConnectivity0->getNumberOfTypes(anEntity0);
 208
 209   checkConnectivity(myConnectivity1, aMeshDimension, aNumberOfNodes, anEntity0, nbOfTypes);
 210
 211   ostringstream ostr1;
 212   ostr1 << *myConnectivity1;
 213   CPPUNIT_ASSERT(ostr1.str() != "");
 214
 215   // COPY
 216   CONNECTIVITY * myConnectivity2 = new CONNECTIVITY(* myConnectivity0);
 217
 218   // Compare
 219   CPPUNIT_ASSERT(myConnectivity2->deepCompare(*myConnectivity0));
 220
 221   // Compare after deleting the initial connectivity
 222   myMesh->removeReference();
 223   myMesh = NULL;
 224   myConnectivity0 = NULL;
 225
 226   MED_EN::medEntityMesh anEntity2 = myConnectivity2->getEntity();
 227   CPPUNIT_ASSERT_EQUAL(anEntity0, anEntity2);
 228
 229   checkConnectivity(myConnectivity2, aMeshDimension, aNumberOfNodes, anEntity0, nbOfTypes);
 230
 231   ostringstream ostr2;
 232   ostr2 << *myConnectivity2;
 233   CPPUNIT_ASSERT(ostr1.str() == ostr2.str());
 234
 235   // ONE MORE COPY
 236   CONNECTIVITY * myConnectivity3 = new CONNECTIVITY(* myConnectivity2);
 237   delete myConnectivity2;
 238
 239   MED_EN::medEntityMesh anEntity3 = myConnectivity3->getEntity();
 240   CPPUNIT_ASSERT_EQUAL(anEntity0, anEntity3);
 241
 242   checkConnectivity(myConnectivity3, aMeshDimension, aNumberOfNodes, anEntity0, nbOfTypes);
 243
 244   ostringstream ostr3;
 245   ostr3 << *myConnectivity3;
 246   CPPUNIT_ASSERT_EQUAL(ostr1.str(), ostr3.str());
 247
 248   delete myConnectivity3;
 249 }
 250
 251 static void createOrCheck (CONNECTIVITY * theC, string msg, bool create = false)
 252 {
 253   // Preconditions: Entity and NumberOfTypes
 254   CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, MED_EN::MED_CELL, theC->getEntity());
 255   CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 3, theC->getNumberOfTypes(MED_EN::MED_CELL));
 256
 257   // EntityDimension
 258   if (create)
 259     // It would be good to set EntityDimension automatically for EDGEs and FACEs,
 260     // and warn about not set EntityDimension for CELLs
 261     // (or calculate it from given geometric types)
 262     theC->setEntityDimension(3);
 263   else
 264     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 3, theC->getEntityDimension());
 265
 266   // NumberOfNodes
 267   int nbNodes = 20;
 268
 269   if (create) {
 270     theC->setNumberOfNodes(nbNodes);
 271   }
 272   else {
 273     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, nbNodes, theC->getNumberOf
 274                                  (MED_EN::MED_NODE, MED_EN::MED_NONE));
 275   }
 276
 277   // GeometricTypes
 278   MED_EN::medGeometryElement aCellTypes[3] = {MED_EN::MED_PYRA5, MED_EN::MED_HEXA8,MED_EN::MED_POLYHEDRA};
 279
 280   // this variable is needed in check mode (!create)
 281   // because of bug with getGlobalNumberingIndex() method (see below)
 282   bool triaFirst = true;
 283
 284   if (create) {
 285     theC->setGeometricTypes(aCellTypes, MED_EN::MED_CELL);
 286     CPPUNIT_ASSERT_THROW(theC->setGeometricTypes(aCellTypes, MED_EN::MED_NODE), MEDEXCEPTION);
 287     CPPUNIT_ASSERT_THROW(theC->setGeometricTypes(aCellTypes, MED_EN::MED_FACE), MEDEXCEPTION);
 288     CPPUNIT_ASSERT_THROW(theC->setGeometricTypes(aCellTypes, MED_EN::MED_EDGE), MEDEXCEPTION);
 289   }
 290   else {
 291     // CELLS: theC
 292     const MED_EN::medGeometryElement * aCellTypesBack = theC->getGeometricTypes(MED_EN::MED_CELL);
 293     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, aCellTypes[0], aCellTypesBack[0]);
 294     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, aCellTypes[1], aCellTypesBack[1]);
 295
 296     const CELLMODEL * aCellModels = theC->getCellsTypes(MED_EN::MED_CELL);
 297     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, aCellTypes[0], aCellModels[0].getType());
 298     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, aCellTypes[1], aCellModels[1].getType());
 299
 300     string * aCellTypesNames = theC->getCellTypeNames(MED_EN::MED_CELL);
 301     CPPUNIT_ASSERT_MESSAGE(msg, aCellTypesNames[0] == "MED_PYRA5");
 302     CPPUNIT_ASSERT_MESSAGE(msg, aCellTypesNames[1] == "MED_HEXA8");
 303     delete [] aCellTypesNames;
 304
 305     // FACES: theC->_constituent
 306     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 3, theC->getNumberOfTypes(MED_EN::MED_FACE));
 307     const MED_EN::medGeometryElement * aFaceTypesBack = theC->getGeometricTypes(MED_EN::MED_FACE);
 308     triaFirst = (aFaceTypesBack[0] == MED_EN::MED_TRIA3 && aFaceTypesBack[1] == MED_EN::MED_QUAD4);
 309     CPPUNIT_ASSERT_MESSAGE(msg, triaFirst || (aFaceTypesBack[1] == MED_EN::MED_TRIA3 &&
 310                                               aFaceTypesBack[0] == MED_EN::MED_QUAD4));
 311
 312     const CELLMODEL * aFaceModels = theC->getCellsTypes(MED_EN::MED_FACE);
 313     bool case1 = (aFaceModels[0].getType() == MED_EN::MED_TRIA3 &&
 314                   aFaceModels[1].getType() == MED_EN::MED_QUAD4);
 315     bool case2 = (aFaceModels[1].getType() == MED_EN::MED_TRIA3 &&
 316                   aFaceModels[0].getType() == MED_EN::MED_QUAD4);
 317     CPPUNIT_ASSERT_MESSAGE(msg, case1 || case2);
 318
 319     string * aFaceTypesNames = theC->getCellTypeNames(MED_EN::MED_FACE);
 320     CPPUNIT_ASSERT_MESSAGE(msg,
 321                            (aFaceTypesNames[0] == "MED_TRIA3" && aFaceTypesNames[1] == "MED_QUAD4") ||
 322                            (aFaceTypesNames[1] == "MED_TRIA3" && aFaceTypesNames[0] == "MED_QUAD4"));
 323     delete [] aFaceTypesNames;
 324     // EDGES: theC->_constituent->_constituent
 325     //CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 1, theC->getNumberOfTypes(MED_EN::MED_EDGE));
 326     //const MED_EN::medGeometryElement * anEdgeTypesBack = theC->getGeometricTypes(MED_EN::MED_EDGE);
 327     //const CELLMODEL * anEdgeModels = theC->getCellsTypes(MED_EN::MED_EDGE);
 328
 329     // invalid cases
 330     CPPUNIT_ASSERT(!theC->getGeometricTypes(MED_EN::MED_NODE));
 331     CPPUNIT_ASSERT(!theC->getGeometricTypes(MED_EN::MED_ALL_ENTITIES));
 332     CPPUNIT_ASSERT_THROW(theC->getCellsTypes(MED_EN::MED_NODE), MEDEXCEPTION);
 333     CPPUNIT_ASSERT_THROW(theC->getCellTypeNames(MED_EN::MED_ALL_ENTITIES), MEDEXCEPTION);
 334   }
 335
 336   // 2 POLYHEDRA
 337   const int nbPolyhedron = 2;
 338   //const int nbPolyFaces = 14; // 13 unique
 339   const int nbPolyNodes = 52 + 14 - 2; // = 64
 340
 341   int aPolyhedronIndex[nbPolyhedron + 1] = {1,33, 65};
 342
 343   int aPolyhedronNodalConnectivity[nbPolyNodes] = {
 344     11,15,19,20,17,13,-1, 11,13,14,-1,  14,13,17,18,-1,  18,17,20,-1,  11,14,15,-1,  15,14,18,19,-1,  19,18,20,
 345     11,13,17,20,19,15,-1, 11,12,13,-1,  13,12,16,17,-1,  17,16,20,-1,  11,15,12,-1,  12,15,19,16,-1,  16,19,20};
 346
 347   //          .11
 348   //
 349   //     13.---------.14
 350   //      /|\       /|
 351   //     / |  \    / |
 352   //    /  |    \ /  |
 353   // 12.---------.15 |
 354   //   |   |     |   |
 355   //   | 17.-----|---.18
 356   //   |  / \    |  /
 357   //   | /    \  | /
 358   //   |/       \|/
 359   // 16.---------.19
 360   //
 361   //          .20
 362
 363   // Nodal Connectivity
 364   int countCells[4] = {1, 3, 4, 6}; // 2 PYRA5 and 1 HEXA8 and 2 POLYHEDRA
 365   int nodesCells_PYRA5[10] = {2,3,4,5,1, 6,7,8,9,10};
 366   int nodesCells_HEXA8[8] = {2,3,4,5, 6,7,8,9};
 367   const int nbClassicCells = countCells[2]-countCells[0];
 368
 369   //          .1
 370   //
 371   //      3.---------.4
 372   //      /|        /|
 373   //     / |       / |
 374   //    /  |      /  |
 375   //  2.---------.5  |
 376   //   |   |     |   |
 377   //   |  7.-----|---.8
 378   //   |  /      |  /
 379   //   | /       | /
 380   //   |/        |/
 381   //  6.---------.9
 382   //
 383   //          .10
 384
 385   // cells index will be: {1, 6, 11, 19}
 386
 387   if (create) {
 388     theC->setCount(countCells, MED_EN::MED_CELL);
 389     theC->setNodal(nodesCells_PYRA5, MED_EN::MED_CELL, MED_EN::MED_PYRA5);
 390     theC->setNodal(nodesCells_HEXA8, MED_EN::MED_CELL, MED_EN::MED_HEXA8);
 391     theC->setNodal(aPolyhedronNodalConnectivity, MED_CELL, MED_POLYHEDRA, aPolyhedronIndex);
 392
 393     // Invalid cases
 394     CPPUNIT_ASSERT_THROW(theC->setCount(countCells, MED_EN::MED_NODE), MEDEXCEPTION);
 395     CPPUNIT_ASSERT_THROW(theC->setCount(countCells, MED_EN::MED_EDGE), MEDEXCEPTION);
 396     CPPUNIT_ASSERT_THROW(theC->setCount(countCells, MED_EN::MED_FACE), MEDEXCEPTION);
 397
 398     CPPUNIT_ASSERT_THROW(theC->setNodal(nodesCells_PYRA5, MED_EN::MED_FACE, MED_EN::MED_PYRA5), MEDEXCEPTION);
 399   }
 400   else {
 401     // CELLS(3D): theC
 402     CPPUNIT_ASSERT_MESSAGE(msg, theC->existConnectivity(MED_EN::MED_NODAL, MED_EN::MED_CELL));
 403     CPPUNIT_ASSERT_MESSAGE(msg, theC->existConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_CELL));
 404
 405     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 2, theC->getNumberOf(MED_EN::MED_CELL, MED_EN::MED_PYRA5));
 406     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 1, theC->getNumberOf(MED_EN::MED_CELL, MED_EN::MED_HEXA8));
 407     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 2, theC->getNumberOf(MED_EN::MED_CELL, MED_EN::MED_POLYHEDRA));
 408     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 5, theC->getNumberOf(MED_EN::MED_CELL, MED_EN::MED_ALL_ELEMENTS));
 409
 410     // sorted by geometric type (order is given by the typedef enum medGeometryElement)
 411     const int * countCellsBack = theC->getGlobalNumberingIndex(MED_EN::MED_CELL);
 412     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, countCells[0], countCellsBack[0]); // 1: always
 413     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, countCells[1], countCellsBack[1]); // 3: +2 PYRA5
 414     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, countCells[2], countCellsBack[2]); // 4: +1 HEXA8
 415     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, countCells[3], countCellsBack[3]); // 6: +2 POLYHEDRA
 416
 417     // nodal connectivity length
 418     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 18+64, theC->getConnectivityLength(MED_EN::MED_NODAL, MED_EN::MED_CELL,
 419                                                                       MED_EN::MED_ALL_ELEMENTS));
 420
 421     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 10, theC->getConnectivityLength(MED_EN::MED_NODAL, MED_EN::MED_CELL,
 422                                                                       MED_EN::MED_PYRA5));
 423
 424     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  8, theC->getConnectivityLength(MED_EN::MED_NODAL, MED_EN::MED_CELL,
 425                                                                       MED_EN::MED_HEXA8));
 426     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  64, theC->getConnectivityLength(MED_EN::MED_NODAL, MED_EN::MED_CELL,
 427                                                                        MED_EN::MED_POLYHEDRA));
 428
 429     // nodal connectivity index
 430     const int * connAllIndex = theC->getConnectivityIndex(MED_EN::MED_NODAL, MED_EN::MED_CELL);
 431     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  1, connAllIndex[0]);
 432     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  6, connAllIndex[1]); // +5 nodes of PYRA5
 433     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 11, connAllIndex[2]); // +5 nodes of PYRA5
 434     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 19, connAllIndex[3]); // +8 nodes of HEXA8
 435     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 19+32, connAllIndex[4]); // +32 nodes of POLYHEDRA
 436     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 19+64, connAllIndex[5]); // +32 nodes of POLYHEDRA
 437
 438     // nodal connectivity
 439     const int * connAll = theC->getConnectivity(MED_EN::MED_NODAL, MED_EN::MED_CELL,
 440                                                 MED_EN::MED_ALL_ELEMENTS);
 441     const int * connPYRA5 = theC->getConnectivity(MED_EN::MED_NODAL, MED_EN::MED_CELL,
 442                                                   MED_EN::MED_PYRA5);
 443     const int * connHEXA8 = theC->getConnectivity(MED_EN::MED_NODAL, MED_EN::MED_CELL,
 444                                                   MED_EN::MED_HEXA8);
 445     const int * connPOLYH = theC->getConnectivity(MED_EN::MED_NODAL, MED_EN::MED_CELL,
 446                                                   MED_EN::MED_POLYHEDRA);
 447     for (int i = 0; i < 10; i++) {
 448       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, nodesCells_PYRA5[i], connPYRA5[i]);
 449       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, nodesCells_PYRA5[i], connAll[i]);
 450     }
 451     for (int i = 0; i < 8; i++) {
 452       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, nodesCells_HEXA8[i], connHEXA8[i]);
 453       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, nodesCells_HEXA8[i], connAll[10 + i]);
 454     }
 455     for (int i = 0; i < 64; i++) {
 456       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, aPolyhedronNodalConnectivity[i], connPOLYH[i]);
 457       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, aPolyhedronNodalConnectivity[i], connAll[18 + i]);
 458     }
 459
 460     // descending connectivity length
 461     // 10 faces in 2 pyra
 462     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 10, theC->getConnectivityLength
 463                                  (MED_EN::MED_DESCENDING, MED_EN::MED_CELL, MED_EN::MED_PYRA5));
 464     // 6 faces in 1 hexa
 465     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  6, theC->getConnectivityLength
 466                                  (MED_EN::MED_DESCENDING, MED_EN::MED_CELL, MED_EN::MED_HEXA8));
 467     // 14 faces in 2 polyhedrons
 468     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  14, theC->getConnectivityLength
 469                                  (MED_EN::MED_DESCENDING, MED_EN::MED_CELL, MED_EN::MED_POLYHEDRA));
 470     // 10 + 6 + 14 faces
 471     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 30, theC->getConnectivityLength
 472                                  (MED_EN::MED_DESCENDING, MED_EN::MED_CELL, MED_EN::MED_ALL_ELEMENTS));
 473
 474     // descending connectivity index
 475     const int * descAllIndex = theC->getConnectivityIndex(MED_EN::MED_DESCENDING, MED_EN::MED_CELL);
 476
 477     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  1, descAllIndex[0]);
 478     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  6, descAllIndex[1]); // +5 faces of PYRA5
 479     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 11, descAllIndex[2]); // +5 faces of PYRA5
 480     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 17, descAllIndex[3]); // +6 faces of HEXA8
 481     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 24, descAllIndex[4]); // +7 faces of POLYHEDRA
 482     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 31, descAllIndex[5]); // +7 faces of POLYHEDRA
 483
 484     // descending connectivity
 485     {
 486       const int * descAll = theC->getConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_CELL,
 487                                                   MED_EN::MED_ALL_ELEMENTS);
 488       const int * descPYRA5 = theC->getConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_CELL,
 489                                                     MED_EN::MED_PYRA5);
 490       const int * descHEXA8 = theC->getConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_CELL,
 491                                                     MED_EN::MED_HEXA8);
 492       const int * descPOLYH = theC->getConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_CELL,
 493                                                     MED_EN::MED_POLYHEDRA);
 494       for (int i = 0; i < 10; i++) {
 495         CPPUNIT_ASSERT_MESSAGE(msg, 0 < labs(descPYRA5[i]) && labs(descPYRA5[i]) < 16);
 496         CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, descAll[i], descPYRA5[i]);
 497       }
 498       for (int i = 0; i < 6; i++) {
 499         CPPUNIT_ASSERT_MESSAGE(msg, 0 < labs(descHEXA8[i]) && labs(descHEXA8[i]) < 16);
 500         CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, descAll[10 + i], descHEXA8[i]);
 501       }
 502       for (int i = 0; i < 14; i++) {
 503         CPPUNIT_ASSERT_MESSAGE(msg, 0 < labs(descPOLYH[i]) && labs(descPOLYH[i]) < 31);
 504         CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, descAll[16 + i], descPOLYH[i]);
 505       }
 506     }
 507
 508     // FACES: theC->_constituent
 509     CPPUNIT_ASSERT_MESSAGE(msg, theC->existConnectivity(MED_EN::MED_NODAL, MED_EN::MED_FACE));
 510     //CPPUNIT_ASSERT_MESSAGE(msg, theC->existConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_FACE));
 511
 512     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  8, theC->getNumberOf(MED_EN::MED_FACE, MED_EN::MED_TRIA3));
 513     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  6, theC->getNumberOf(MED_EN::MED_FACE, MED_EN::MED_QUAD4));
 514     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  13, theC->getNumberOf(MED_EN::MED_FACE, MED_EN::MED_POLYGON));
 515     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 27, theC->getNumberOf(MED_EN::MED_FACE, MED_EN::MED_ALL_ELEMENTS));
 516
 517     // sorted by geometric type
 518     const int * countFacesBack = theC->getGlobalNumberingIndex(MED_EN::MED_FACE);
 519     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  1, countFacesBack[0]); // always
 520
 521     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  9, countFacesBack[1]); // +8 TRIA3
 522
 523     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 15, countFacesBack[2]); // 1+8+6
 524
 525     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 28, countFacesBack[3]); // 1+8+6+13
 526
 527     // nodal connectivity length // 8*3 + 6*4 + 46
 528     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 48+46, theC->getConnectivityLength(MED_EN::MED_NODAL, MED_EN::MED_FACE,
 529                                                                                   MED_EN::MED_ALL_ELEMENTS));
 530
 531     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 24, theC->getConnectivityLength(MED_EN::MED_NODAL, MED_EN::MED_FACE,
 532                                                                       MED_EN::MED_TRIA3));
 533     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 24, theC->getConnectivityLength(MED_EN::MED_NODAL, MED_EN::MED_FACE,
 534                                                                       MED_EN::MED_QUAD4));
 535     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 46, theC->getConnectivityLength(MED_EN::MED_NODAL, MED_EN::MED_FACE,
 536                                                                                MED_EN::MED_POLYGON));
 537
 538     // nodal connectivity index
 539     const int * connFaceAllIndex = theC->getConnectivityIndex(MED_EN::MED_NODAL, MED_EN::MED_FACE);
 540     {
 541       CPPUNIT_ASSERT(triaFirst);
 542       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  1, connFaceAllIndex[0]);
 543       int typeChangeIndex = 8;
 544       int nbNodes1 = 3;
 545       int nbNodes2 = 4;
 546       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 25, connFaceAllIndex[typeChangeIndex]); // + 3*8 or 4*6
 547       for (int i = 1; i < 14; i++) {
 548         if (i < typeChangeIndex)
 549           CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 1 + i*nbNodes1, connFaceAllIndex[i]);
 550         else
 551           CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 25 + (i-typeChangeIndex)*nbNodes2, connFaceAllIndex[i]);
 552       }
 553       // + 3*8 nodes of TRIA3 + 4*6 nodes of QUAD4
 554       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 49, connFaceAllIndex[14]);
 555     }
 556
 557     // nodal connectivity
 558     const int * connFaceAll = theC->getConnectivity(MED_EN::MED_NODAL, MED_EN::MED_FACE,
 559                                                     MED_EN::MED_ALL_ELEMENTS);
 560     const int * connTRIA3 = theC->getConnectivity(MED_EN::MED_NODAL, MED_EN::MED_FACE,
 561                                                   MED_EN::MED_TRIA3);
 562     const int * connQUAD4 = theC->getConnectivity(MED_EN::MED_NODAL, MED_EN::MED_FACE,
 563                                                   MED_EN::MED_QUAD4);
 564     for (int i = 0; i < 24; i++) {
 565       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, connFaceAll[   i], connTRIA3[i]);
 566       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, connFaceAll[24+i], connQUAD4[i]);
 567     }
 568
 569     // EDGES: theC->_constituent->_constituent
 570     //CPPUNIT_ASSERT_MESSAGE(msg, theC->existConnectivity(MED_EN::MED_NODAL, MED_EN::MED_EDGE));
 571
 572     // Invalid cases
 573     CPPUNIT_ASSERT_MESSAGE(msg, !theC->existConnectivity(MED_EN::MED_NODAL, MED_EN::MED_NODE));
 574     CPPUNIT_ASSERT_MESSAGE(msg, !theC->existConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_EDGE));
 575     CPPUNIT_ASSERT_MESSAGE(msg, !theC->existConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_NODE));
 576     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 0, theC->getNumberOf(MED_EN::MED_CELL, MED_EN::MED_TETRA4));
 577     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 0, theC->getNumberOf(MED_EN::MED_CELL,
 578                                                                    MED_EN::MED_TETRA4));
 579     CPPUNIT_ASSERT_THROW(theC->getConnectivityLength(MED_EN::MED_NODAL, MED_EN::MED_CELL,
 580                                                      MED_EN::MED_TRIA3), MEDEXCEPTION);
 581     CPPUNIT_ASSERT_THROW(theC->getConnectivityLength(MED_EN::MED_DESCENDING, MED_EN::MED_CELL,
 582                                                      MED_EN::MED_NONE), MEDEXCEPTION);
 583     CPPUNIT_ASSERT_THROW(theC->getConnectivityLength(MED_EN::MED_NODAL, MED_EN::MED_CELL,
 584                                                      MED_EN::MED_POLYGON), MEDEXCEPTION);
 585   }
 586
 587
 588   if (create) {
 589   }
 590   else {
 591     // CELLS(3D): theC
 592     {
 593       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 3, theC->getNumberOfTypes(MED_EN::MED_CELL));
 594
 595       {
 596         const MED_EN::medGeometryElement * aCellTypesBack = theC->getGeometricTypes(MED_EN::MED_CELL);
 597         CPPUNIT_ASSERT_MESSAGE(msg, ((aCellTypesBack[0] == MED_EN::MED_PYRA5 &&
 598                                       aCellTypesBack[1] == MED_EN::MED_HEXA8) ||
 599                                      (aCellTypesBack[0] == MED_EN::MED_HEXA8 &&
 600                                       aCellTypesBack[1] == MED_EN::MED_PYRA5)));
 601         CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, MED_EN::MED_POLYHEDRA, aCellTypesBack[2]);
 602       }
 603
 604       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 2, theC->getNumberOf(MED_EN::MED_CELL,
 605                                                              MED_EN::MED_POLYHEDRA));
 606       //checking that 0 is returned if polygons are asked as cells instead of faces
 607       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 0, theC->getNumberOf(MED_EN::MED_CELL,
 608                                                              MED_EN::MED_POLYGON));
 609
 610
 611       int nbCellAll = 5; // 2 (PYRA5) + 1 (HEXA8) + 2 (POLYHEDRA)
 612
 613       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, nbCellAll, theC->getNumberOf
 614                                    (MED_EN::MED_CELL, MED_EN::MED_ALL_ELEMENTS));
 615
 616
 617       // first PYRA5 {1,2,3,4,5}
 618       {
 619         int len;
 620         const int * c1 = theC->getConnectivityOfAnElement
 621           (MED_EN::MED_NODAL, MED_EN::MED_CELL, /*Number*/1, len);
 622         CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 5, len);
 623         for (int i = 0; i < len; i++) {
 624           if (c1[i] < 1 || 5 < c1[i]) CPPUNIT_FAIL(msg);
 625         }
 626       }
 627
 628       // first POLYHEDRA
 629       {
 630         int len;
 631         const int* con = 0;
 632         CPPUNIT_ASSERT_NO_THROW(con=theC->getConnectivityOfAnElement
 633                                 (MED_EN::MED_NODAL, MED_EN::MED_CELL, /*Number*/4, len));
 634         CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 32, len);
 635         for (int i = 0; i < len; i++)
 636           CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,aPolyhedronNodalConnectivity[i],con[i]);
 637       }
 638
 639       // cells descending connectivity
 640       for (int i = 1; i <= nbCellAll; i++) {
 641         int len;
 642         const int * ci = theC->getConnectivityOfAnElement
 643           (MED_EN::MED_DESCENDING, MED_EN::MED_CELL, /*Number*/i, len);
 644
 645         MED_EN::medGeometryElement aCurElemType = theC->getElementType(MED_EN::MED_CELL, i);
 646
 647         if (i <= 3) { // nb.standard cells = 3
 648           // sign of connectivity array value means element direction
 649           for (int j = 0; j < len; j++) {
 650             CPPUNIT_ASSERT_MESSAGE(msg, 0 < labs(ci[j]) && labs(ci[j]) <= 14); // nb.standard faces = 14
 651           }
 652         }
 653         else {
 654           CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, MED_EN::MED_POLYHEDRA, aCurElemType);
 655           for (int j = 0; j < len; j++) {
 656             CPPUNIT_ASSERT_MESSAGE(msg, 14 < labs(ci[j]) && labs(ci[j]) <= 27); // nb.polygons = 13
 657           }
 658         }
 659
 660         switch (aCurElemType) {
 661         case MED_EN::MED_PYRA5:     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 5, len); break;
 662         case MED_EN::MED_HEXA8:     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 6, len); break;
 663         case MED_EN::MED_POLYHEDRA: CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 7, len); break;
 664         default:
 665           CPPUNIT_FAIL(msg); // wrong element type
 666         }
 667       }
 668
 669       // Polyhedron-specific methods
 670       {
 671         CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 2, theC->getNumberOf(MED_EN::MED_CELL,
 672                                                                MED_EN::MED_POLYHEDRA));
 673
 674         // getNodesOfPolyhedron
 675         int lenPolyh1nodes, lenPolyh2nodes; // nb of unique nodes
 676         int * polyh1nodes = theC->getNodesOfPolyhedron(/*polyhedronId*/3+1, lenPolyh1nodes);
 677         int * polyh2nodes = theC->getNodesOfPolyhedron(/*polyhedronId*/3+2, lenPolyh2nodes);
 678         CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 8, lenPolyh1nodes);
 679         CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 8, lenPolyh2nodes);
 680
 681         set<int> polyh1nodesCheck;
 682         set<int> polyh2nodesCheck;
 683
 684         polyh1nodesCheck.insert(11);
 685         polyh1nodesCheck.insert(13);
 686         polyh1nodesCheck.insert(14);
 687         polyh1nodesCheck.insert(15);
 688         polyh1nodesCheck.insert(17);
 689         polyh1nodesCheck.insert(18);
 690         polyh1nodesCheck.insert(19);
 691         polyh1nodesCheck.insert(20);
 692
 693         polyh2nodesCheck.insert(11);
 694         polyh2nodesCheck.insert(12);
 695         polyh2nodesCheck.insert(13);
 696         polyh2nodesCheck.insert(15);
 697         polyh2nodesCheck.insert(16);
 698         polyh2nodesCheck.insert(17);
 699         polyh2nodesCheck.insert(19);
 700         polyh2nodesCheck.insert(20);
 701
 702         for (int i = 0; i < 8; i++) {
 703           CPPUNIT_ASSERT_MESSAGE(msg, polyh1nodesCheck.count(polyh1nodes[i]));
 704           CPPUNIT_ASSERT_MESSAGE(msg, polyh2nodesCheck.count(polyh2nodes[i]));
 705         }
 706         delete [] polyh1nodes;
 707         delete [] polyh2nodes;
 708
 709         // getNodesPerFaceOfPolyhedron
 710         int nbFaces1, nbFaces2;
 711         int *nbNodes1, *nbNodes2; // len = nb.faces (7)
 712         int ** polyh1nodesPerFace =
 713           theC->getNodesPerFaceOfPolyhedron(/*polyhedronId*/3+1, nbFaces1, nbNodes1);
 714         int ** polyh2nodesPerFace =
 715           theC->getNodesPerFaceOfPolyhedron(/*polyhedronId*/3+2, nbFaces2, nbNodes2);
 716
 717         CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 7, nbFaces1);
 718         CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 7, nbFaces2);
 719
 720         int nbNodesCheck [7] = {6,3,4,3,3,4,3};
 721         int startNode1 = aPolyhedronIndex[0] - 1;
 722         int startNode2 = aPolyhedronIndex[1] - 1;
 723         for (int i = 0; i < 7; i++) {
 724           CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, nbNodesCheck[i], nbNodes1[i]);
 725           CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, nbNodesCheck[i], nbNodes2[i]);
 726
 727           for (int j = 0; j < nbNodesCheck[i]; j++) {
 728             CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, aPolyhedronNodalConnectivity[startNode1],
 729                                          polyh1nodesPerFace[i][j]);
 730             CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, aPolyhedronNodalConnectivity[startNode2],
 731                                          polyh2nodesPerFace[i][j]);
 732             startNode1++;
 733             startNode2++;
 734           }
 735           startNode1++;
 736           startNode2++;
 737         }
 738
 739         delete [] nbNodes1;
 740         delete [] nbNodes2;
 741         delete [] polyh1nodesPerFace;
 742         delete [] polyh2nodesPerFace;
 743
 744         // invalid polyhedron Id
 745
 746         int lenPolyh3nodes;
 747         int nbFaces3;
 748         int *nbNodes3;
 749
 750         CPPUNIT_ASSERT_THROW(theC->getNodesOfPolyhedron(1, lenPolyh3nodes), MEDEXCEPTION);
 751         CPPUNIT_ASSERT_THROW(theC->getNodesOfPolyhedron(3+3, lenPolyh3nodes), MEDEXCEPTION);
 752         CPPUNIT_ASSERT_THROW(theC->getNodesPerFaceOfPolyhedron
 753                              (/*polyhedronId*/1, nbFaces3, nbNodes3), MEDEXCEPTION);
 754         CPPUNIT_ASSERT_THROW(theC->getNodesPerFaceOfPolyhedron
 755                              (/*polyhedronId*/3+3, nbFaces3, nbNodes3), MEDEXCEPTION);
 756
 757
 758         // Descending
 759
 760         // PolyhedronIndex: array of size (NumberOfPolyhedron + 1)
 761         const int* polyhDesceIndex = theC->getConnectivityIndex(MED_EN::MED_DESCENDING,MED_EN::MED_CELL);
 762         CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  polyhDesceIndex[nbClassicCells+0]+7, polyhDesceIndex[nbClassicCells+1]); // +7 faces
 763         CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  polyhDesceIndex[nbClassicCells+1]+7, polyhDesceIndex[nbClassicCells+2]); // +7 faces
 764
 765         // Polyhedron Descending Connectivity: array of size (NumberOfPolyhedronFaces)
 766         const int* polyhDesceConn = theC->getConnectivity(MED_EN::MED_DESCENDING,MED_EN::MED_CELL,MED_EN::MED_POLYHEDRA);
 767         // 15,16,17,18,19,20,21, -15,22,23,24,25,26,27
 768         for (int i = 0; i < 14; i++) {
 769           // nb. poly faces = 13, because one face is common for two polyhedra
 770           // nb. standard faces < poly-face id <= 27 (27 = 14 + 13)
 771           CPPUNIT_ASSERT_MESSAGE(msg, 14 < labs(polyhDesceConn[i]) && labs(polyhDesceConn[i]) <= 27);
 772         }
 773       } // Polyhedron-specific methods
 774
 775       // Polygon-specific methods
 776       {
 777         // Invalid cases: no polygons for MED_CELL in theC
 778         CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 0, theC->getNumberOf(MED_EN::MED_CELL,MED_EN::MED_POLYGON));
 779         CPPUNIT_ASSERT_THROW(theC->getConnectivity(MED_EN::MED_DESCENDING,
 780                                                    MED_EN::MED_CELL,MED_EN::MED_POLYGON), MEDEXCEPTION);
 781       }
 782     } // CELLS: theC
 783
 784     // FACES: theC->_constituent
 785     {
 786       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 3, theC->getNumberOfTypes(MED_EN::MED_FACE));
 787
 788       const MED_EN::medGeometryElement * aFaceTypesBack = theC->getGeometricTypes(MED_EN::MED_FACE);
 789       CPPUNIT_ASSERT_MESSAGE(msg, ((aFaceTypesBack[0] == MED_EN::MED_TRIA3 &&
 790                                     aFaceTypesBack[1] == MED_EN::MED_QUAD4) ||
 791                                    (aFaceTypesBack[0] == MED_EN::MED_QUAD4 &&
 792                                     aFaceTypesBack[1] == MED_EN::MED_TRIA3)));
 793       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, MED_EN::MED_POLYGON, aFaceTypesBack[2]);
 794
 795       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  0, theC->getNumberOf
 796                                    (MED_EN::MED_FACE, MED_EN::MED_POLYHEDRA));
 797
 798       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 13, theC->getNumberOf
 799                                    (MED_EN::MED_FACE, MED_EN::MED_POLYGON));
 800
 801       int nbFaAll = 27; // 6 (QUAD4) + 8 (TRIA3) + 13 (POLYGON)
 802
 803       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, nbFaAll, theC->getNumberOf
 804                                    (MED_EN::MED_FACE, MED_EN::MED_ALL_ELEMENTS));
 805
 806
 807       bool isHexagon = false;
 808       for (int i = 1; i <= nbFaAll; i++) {
 809         int len;
 810         const int * ci = theC->getConnectivityOfAnElement(MED_EN::MED_NODAL,
 811                                                                   MED_EN::MED_FACE, /*Number*/i, len);
 812         MED_EN::medGeometryElement aCurElemType = theC->getElementType(MED_EN::MED_FACE, i);
 813
 814         if (len == 6) {
 815           CPPUNIT_ASSERT_MESSAGE(msg, !isHexagon); // because only one hexagon must exist
 816
 817           // check nodes {11,15,19,20,17,13}
 818           int nij;
 819           for (int j = 0; j < len; j++) {
 820             nij = ci[j];
 821             CPPUNIT_ASSERT_MESSAGE(msg, nij==11 || nij==15 || nij==19 || nij==20 || nij==17 || nij==13);
 822           }
 823
 824           isHexagon = true;
 825         }
 826
 827         switch (aCurElemType) {
 828         case MED_EN::MED_TRIA3:   CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 3, len); break;
 829         case MED_EN::MED_QUAD4:   CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 4, len); break;
 830         case MED_EN::MED_POLYGON: CPPUNIT_ASSERT_MESSAGE(msg, len == 3 || len == 4 || len == 6); break;
 831         default:
 832           CPPUNIT_FAIL(msg); // wrong element type
 833         }
 834       }
 835       CPPUNIT_ASSERT_MESSAGE(msg, isHexagon); // hexagon must exist
 836
 837       // Polygon-specific methods
 838       {
 839         CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 13, theC->getNumberOf(MED_EN::MED_FACE,MED_EN::MED_POLYGON));
 840
 841         const int * pgIndx = theC->getConnectivityIndex(MED_EN::MED_NODAL, MED_EN::MED_FACE) + 8+6;
 842         CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 46, pgIndx[13]-pgIndx[0]);
 843
 844         const int * pgConn = theC->getConnectivity(MED_EN::MED_NODAL, MED_EN::MED_FACE, MED_EN::MED_ALL_ELEMENTS);
 845
 846         // face #  1: 11 15 19 20 17 13
 847         // face #  2: 11 13 14
 848         // face #  3: 14 13 17 18
 849         // face #  4: 18 17 20
 850         // face #  5: 11 14 15
 851         // face #  6: 15 14 18 19
 852         // face #  7: 19 18 20
 853         // face #  8: 11 12 13
 854         // face #  9: 13 12 16 17
 855         // face # 10: 17 16 20
 856         // face # 11: 11 15 12
 857         // face # 12: 12 15 19 16
 858         // face # 13: 16 19 20
 859
 860         for (int i = 0; i < 13; i++) {
 861           int startNode = pgIndx[i];
 862           int finishNode = pgIndx[i+1];
 863           // check nodes uniqueness inside one polygon
 864           set<int> curNodes;
 865           for (int j = startNode; j < finishNode; j++) {
 866             CPPUNIT_ASSERT_MESSAGE(msg, (curNodes.insert(pgConn[j - 1])).second);
 867           }
 868         }
 869       }
 870     } // FACES: theC->_constituent
 871
 872     // EDGES: theC->_constituent->_constituent
 873     //CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 2, theC->getNumberOfTypes(MED_EN::MED_EDGE));
 874   }
 875
 876   if (create) {
 877     // force _constituent computation
 878     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 3, theC->getNumberOfTypes(MED_EN::MED_FACE));
 879
 880
 881     //N-2 Connectivity not supported in MEDMEM
 882     //CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 1, theC->getNumberOfTypes(MED_EN::MED_EDGE));
 883
 884   }
 885   else {
 886     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, MED_EN::MED_POLYHEDRA, theC->getPolyTypeRelativeTo());
 887
 888     // The following methods are not recursive, i.e. they return types
 889     // of this connectivity, but do not return types of _constituent.
 890     // And these methods DO work with poly-types.
 891
 892     // getType
 893     const CELLMODEL & aPYRA5_type = theC->getType(MED_EN::MED_PYRA5);
 894     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, MED_EN::MED_PYRA5, aPYRA5_type.getType());
 895     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 5, aPYRA5_type.getNumberOfVertexes());
 896
 897     const CELLMODEL & aHEXA8_type = theC->getType(MED_EN::MED_HEXA8);
 898     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 8, aHEXA8_type.getNumberOfNodes());
 899     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 3, aHEXA8_type.getDimension());
 900     // nb. of sub-faces (nb. of constituents with dimension = 3 - 1)
 901     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 6, aHEXA8_type.getNumberOfConstituents(1));
 902
 903     const CELLMODEL & aPOLYH_type = theC->getType(MED_EN::MED_POLYHEDRA);
 904     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 0, aPOLYH_type.getNumberOfNodes());
 905     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 3, aPOLYH_type.getDimension());
 906
 907     CPPUNIT_ASSERT_THROW(theC->getType(MED_EN::MED_TRIA3), MEDEXCEPTION);
 908     CPPUNIT_ASSERT_THROW(theC->getType(MED_EN::MED_POLYGON), MEDEXCEPTION);
 909     CPPUNIT_ASSERT_THROW(theC->getType(MED_EN::MED_NONE), MEDEXCEPTION);
 910     CPPUNIT_ASSERT_THROW(theC->getType(MED_EN::MED_ALL_ELEMENTS), MEDEXCEPTION);
 911
 912     // getNumberOfNodesInType
 913     int nbNodesInPYRA5 = theC->getNumberOfNodesInType(MED_EN::MED_PYRA5);
 914     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 5, nbNodesInPYRA5);
 915
 916     CPPUNIT_ASSERT_THROW(theC->getNumberOfNodesInType(MED_EN::MED_TRIA3), MEDEXCEPTION);
 917     CPPUNIT_ASSERT_THROW(theC->getNumberOfNodesInType(MED_EN::MED_POLYGON), MEDEXCEPTION);
 918     CPPUNIT_ASSERT_THROW(theC->getNumberOfNodesInType(MED_EN::MED_NONE), MEDEXCEPTION);
 919
 920     // getNumberOfSubCellInType
 921     int nbFacesInHEXA8 = theC->getNumberOfSubCellInType(MED_EN::MED_HEXA8);
 922     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 6, nbFacesInHEXA8);
 923
 924     int nbFacesInPOLYH = theC->getNumberOfSubCellInType(MED_EN::MED_POLYHEDRA);
 925     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 0, nbFacesInPOLYH);
 926
 927     CPPUNIT_ASSERT_THROW(theC->getNumberOfSubCellInType(MED_EN::MED_QUAD4), MEDEXCEPTION);
 928     CPPUNIT_ASSERT_THROW(theC->getNumberOfSubCellInType(MED_EN::MED_ALL_ELEMENTS), MEDEXCEPTION);
 929
 930     // getValueIndex
 931     const int* nodalIndex = theC->getValueIndex(MED_EN::MED_NODAL);
 932     const int* desceIndex = theC->getValueIndex(MED_EN::MED_DESCENDING);
 933
 934     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  1, nodalIndex[0]);
 935     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  6, nodalIndex[1]); // +5 nodes of PYRA5
 936     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 11, nodalIndex[2]); // +5 nodes of PYRA5
 937     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 19, nodalIndex[3]); // +8 nodes of HEXA8
 938
 939     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  1, desceIndex[0]);
 940     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg,  6, desceIndex[1]); // +5 faces of PYRA5
 941     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 11, desceIndex[2]); // +5 faces of PYRA5
 942     CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, 17, desceIndex[3]); // +6 faces of HEXA8
 943
 944     // getValue
 945     const int* nodalValue = theC->getValue(MED_EN::MED_NODAL, MED_EN::MED_ALL_ELEMENTS);
 946     const int* nodalPYRA5 = theC->getValue(MED_EN::MED_NODAL, MED_EN::MED_PYRA5);
 947     const int* nodalHEXA8 = theC->getValue(MED_EN::MED_NODAL, MED_EN::MED_HEXA8);
 948
 949     for (int i = 0; i < 10; i++) {
 950       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, nodesCells_PYRA5[i], nodalPYRA5[i]);
 951       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, nodesCells_PYRA5[i], nodalValue[i]);
 952     }
 953     for (int i = 0; i < 8; i++) {
 954       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, nodesCells_HEXA8[i], nodalHEXA8[i]);
 955       CPPUNIT_ASSERT_EQUAL_MESSAGE(msg, nodesCells_HEXA8[i], nodalValue[10 + i]);
 956     }
 957
 958     const int* desceValue = theC->getValue(MED_EN::MED_DESCENDING, MED_EN::MED_ALL_ELEMENTS);
 959     const int* descePYRA5 = theC->getValue(MED_EN::MED_DESCENDING, MED_EN::MED_PYRA5);
 960     const int* desceHEXA8 = theC->getValue(MED_EN::MED_DESCENDING, MED_EN::MED_HEXA8);
 961
 962     for (int i = 0; i < 10; i++) {
 963       CPPUNIT_ASSERT_MESSAGE(msg, 0 < labs(descePYRA5[i]) && labs(descePYRA5[i]) < 16);
 964
 965       CPPUNIT_ASSERT_MESSAGE(msg, 0 < labs(desceValue[i]) && labs(desceValue[i]) < 16);
 966     }
 967     for (int i = 0; i < 6; i++) {
 968       CPPUNIT_ASSERT_MESSAGE(msg, 0 < labs(desceHEXA8[i]) && labs(desceHEXA8[i]) < 16);
 969       CPPUNIT_ASSERT_MESSAGE(msg, 0 < labs(desceValue[10 + i]) && labs(desceValue[10 + i]) < 16);
 970     }
 971
 972     CPPUNIT_ASSERT_THROW(theC->getValue(MED_EN::MED_NODAL, MED_EN::MED_QUAD4), MEDEXCEPTION);
 973     CPPUNIT_ASSERT_THROW(theC->getValue(MED_EN::MED_NODAL, MED_EN::MED_POLYGON), MEDEXCEPTION);
 974     CPPUNIT_ASSERT_THROW(theC->getValue(MED_EN::MED_DESCENDING, MED_EN::MED_NONE), MEDEXCEPTION);
 975   }
 976 }
 977
 978 void MEDMEMTest::testConnectivity()
 979 {
 980   //////////////////////////////////////////////
 981   // TEST 1: test_MEDMEM_PolyConnectivity.cxx //
 982   //////////////////////////////////////////////
 983   CONNECTIVITY myNodalConnectivity(1); // one type
 984   myNodalConnectivity.setEntityDimension(3);
 985
 986   MED_EN::medGeometryElement types[] = { MED_EN::MED_POLYHEDRA };
 987
 988   //POLYHEDRON
 989   const int NumberOfPolyhedron = 2;
 990   int PolyhedronIndex[NumberOfPolyhedron+1] = {1,47,91};
 991
 992   //Nodal
 993   const int NumberOfFaces = 19;
 994   int PolyhedronNodalConnectivity[] ={1, 2, 3, 4, 5, 6, -1,// Polyhedron 1
 995                                       1, 7, 8, 2,       -1,
 996                                       2, 8, 9, 3,       -1,
 997                                       4, 3, 9, 10,      -1,
 998                                       5, 4, 10, 11,     -1,
 999                                       6, 5, 11, 12,     -1,
1000                                       1, 6, 12, 7,      -1,
1001                                       7, 12, 8,         -1,
1002                                       10, 9, 8, 12, 11,
1003
1004                                       13, 14, 15, 3, 2, -1,// Polyhedron 2
1005                                       13, 2, 8, 16,     -1,
1006                                       14, 13, 16, 17,   -1,
1007                                       15, 14, 17,       -1,
1008                                       15, 17, 18,       -1,
1009                                       15, 18, 9,        -1,
1010                                       3, 15, 9,         -1,
1011                                       2, 3, 9, 8,       -1,
1012                                       8, 9, 17, 16,     -1,
1013                                       9, 18, 17 };
1014
1015   const int count[] = { 1, 1+NumberOfPolyhedron };
1016   myNodalConnectivity.setGeometricTypes( &types[0], MED_EN::MED_CELL );
1017   myNodalConnectivity.setCount( count, MED_EN::MED_CELL );
1018   myNodalConnectivity.setNodal( PolyhedronNodalConnectivity, MED_EN::MED_CELL,
1019                                 MED_EN::MED_POLYHEDRA, PolyhedronIndex);
1020
1021   myNodalConnectivity.setNumberOfNodes(777);
1022   CPPUNIT_ASSERT_EQUAL(777, myNodalConnectivity.getNumberOf
1023                        (MED_EN::MED_NODE, MED_EN::MED_NONE));
1024 //   // Throws because _constituent is not calculated
1025 //   CPPUNIT_ASSERT_THROW(myNodalConnectivity.getNumberOf
1026 //                        (MED_EN::MED_FACE, MED_EN::MED_NONE), MEDEXCEPTION);
1027
1028 //   // Returns zero, because EntityDimension is not set
1029 //   CPPUNIT_ASSERT_EQUAL(0, myNodalConnectivity.getNumberOf
1030 //                        (MED_EN::MED_CELL, MED_EN::MED_POLYGON));
1031 //   CPPUNIT_ASSERT_EQUAL(0, myNodalConnectivity.getNumberOf
1032 //                        (MED_EN::MED_CELL, MED_EN::MED_POLYHEDRA));
1033
1034   // Throws because entity must differ from MED_NONE and MED_ALL_ELEMENTS
1035   CPPUNIT_ASSERT_THROW(myNodalConnectivity.getNumberOfNodesInType(MED_EN::MED_NONE), MEDEXCEPTION);
1036   CPPUNIT_ASSERT_THROW(myNodalConnectivity.getNumberOfNodesInType(MED_EN::MED_ALL_ELEMENTS), MEDEXCEPTION);
1037
1038   // Throws because types are not defined
1039   CPPUNIT_ASSERT_THROW(myNodalConnectivity.getNumberOfNodesInType(MED_EN::MED_ALL_ELEMENTS), MEDEXCEPTION);
1040   CPPUNIT_ASSERT_THROW(myNodalConnectivity.getNumberOfNodesInType(MED_EN::MED_POLYGON), MEDEXCEPTION);
1041
1042   // does not throw any more exception because
1043   // it is now possible to work on meshes with only polyhedric elements
1044   CPPUNIT_ASSERT_NO_THROW(myNodalConnectivity.calculateConnectivity (MED_EN::MED_DESCENDING,
1045                                                                      MED_EN::MED_CELL));
1046
1047   // existPolygonsConnectivity
1048   CPPUNIT_ASSERT(myNodalConnectivity.existConnectivity(MED_EN::MED_NODAL, MED_EN::MED_FACE));
1049   CPPUNIT_ASSERT(!myNodalConnectivity.existConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_FACE));
1050
1051   // existPolyhedronConnectivity
1052   CPPUNIT_ASSERT(myNodalConnectivity.existConnectivity(MED_EN::MED_NODAL, MED_EN::MED_CELL));
1053   CPPUNIT_ASSERT(myNodalConnectivity.existConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_CELL));
1054
1055
1056   // setEntityDimension
1057   // it contains cells of different dimension (2D and 3D)
1058   // We set here EntityDimension for good work of below methods
1059
1060   CPPUNIT_ASSERT_EQUAL(MED_EN::MED_POLYHEDRA, myNodalConnectivity.getPolyTypeRelativeTo());
1061
1062   // Poly types
1063   CPPUNIT_ASSERT_EQUAL(1, myNodalConnectivity.getNumberOfTypes(MED_EN::MED_CELL));
1064
1065   CPPUNIT_ASSERT_EQUAL(1, myNodalConnectivity.getNumberOfTypes(MED_EN::MED_FACE));
1066
1067   // getNumberOf
1068   CPPUNIT_ASSERT_EQUAL(NumberOfPolyhedron, myNodalConnectivity.getNumberOf
1069                        (MED_EN::MED_CELL, MED_EN::MED_POLYHEDRA));
1070   CPPUNIT_ASSERT_EQUAL(0, myNodalConnectivity.getNumberOf
1071                        (MED_EN::MED_CELL, MED_EN::MED_POLYGON));
1072   //Minus 1 because 2,3,8,9 is a given twice in connectivity
1073   CPPUNIT_ASSERT_EQUAL(NumberOfFaces-1, myNodalConnectivity.getNumberOf (MED_EN::MED_FACE,
1074                                                                          MED_EN::MED_POLYGON));
1075
1076   // getConnectivityOfAnElement
1077   {
1078     //first polyhedron
1079     const int *ph1, *ph2;
1080     int len_ph1, len_ph2;
1081     CPPUNIT_ASSERT_NO_THROW(ph1 = myNodalConnectivity.getConnectivityOfAnElement
1082                             (MED_EN::MED_NODAL, MED_EN::MED_CELL, /*Number*/1, len_ph1));
1083     CPPUNIT_ASSERT_EQUAL( PolyhedronIndex[1]-PolyhedronIndex[0], len_ph1 );
1084     CPPUNIT_ASSERT( vector<int>( PolyhedronNodalConnectivity, PolyhedronNodalConnectivity + len_ph1) ==
1085                     vector<int>( ph1, ph1+len_ph1 ));
1086
1087     //second polyhedron
1088     CPPUNIT_ASSERT_NO_THROW(ph2 = myNodalConnectivity.getConnectivityOfAnElement
1089                             (MED_EN::MED_NODAL, MED_EN::MED_CELL, /*Number*/2, len_ph2));
1090     CPPUNIT_ASSERT_EQUAL( PolyhedronIndex[2]-PolyhedronIndex[1], len_ph2 );
1091     CPPUNIT_ASSERT( vector<int>( PolyhedronNodalConnectivity + len_ph1, PolyhedronNodalConnectivity + len_ph1 + len_ph2) ==
1092                     vector<int>( ph2, ph2+len_ph2 ));
1093
1094     // MED_DESCENDING
1095     //first polyhedron
1096     CPPUNIT_ASSERT_NO_THROW(ph1 = myNodalConnectivity.getConnectivityOfAnElement
1097                             (MED_EN::MED_DESCENDING, MED_EN::MED_CELL, /*Number*/1, len_ph1));
1098     CPPUNIT_ASSERT_EQUAL( 9, len_ph1 );
1099     const int faces1[] = { 1,2,3,4,5,6,7,8,9 };
1100     CPPUNIT_ASSERT( vector<int>( faces1, faces1 + len_ph1 ) ==
1101                     vector<int>( ph1, ph1+len_ph1 ));
1102
1103     //second polyhedron
1104     CPPUNIT_ASSERT_NO_THROW(ph2 = myNodalConnectivity.getConnectivityOfAnElement
1105                             (MED_EN::MED_DESCENDING, MED_EN::MED_CELL, /*Number*/2, len_ph2));
1106     CPPUNIT_ASSERT_EQUAL( 10, len_ph2 );
1107     const int faces2[] = { 10,11,12,13,14,15,16,-3,17,18 };
1108     CPPUNIT_ASSERT( vector<int>( faces2, faces2 + len_ph2 ) ==
1109                     vector<int>( ph2, ph2+len_ph2 ));
1110   }
1111
1112   // We reset here EntityDimension to check getConnectivityOfAnElement()
1113   //myNodalConnectivity.setEntityDimension(2);
1114
1115   {
1116     const int *ph1, *ph2;
1117     int len_ph1, len_ph2;
1118     // first polygon
1119     CPPUNIT_ASSERT_NO_THROW(ph1 = myNodalConnectivity.getConnectivityOfAnElement
1120                             (MED_EN::MED_NODAL, MED_EN::MED_FACE, /*Number*/1, len_ph1));
1121     CPPUNIT_ASSERT_EQUAL( 6, len_ph1 );
1122     CPPUNIT_ASSERT( vector<int>( PolyhedronNodalConnectivity, PolyhedronNodalConnectivity + len_ph1) ==
1123                     vector<int>( ph1, ph1+len_ph1 ));
1124
1125     // second polygon
1126     CPPUNIT_ASSERT_NO_THROW(ph2 = myNodalConnectivity.getConnectivityOfAnElement
1127                             (MED_EN::MED_NODAL, MED_EN::MED_FACE, /*Number*/2, len_ph2));
1128     CPPUNIT_ASSERT_EQUAL( 4, len_ph2 );
1129     CPPUNIT_ASSERT( vector<int>( PolyhedronNodalConnectivity + len_ph1 + 1, PolyhedronNodalConnectivity + len_ph1 + 1 + len_ph2) ==
1130                     vector<int>( ph2, ph2+len_ph2 ));
1131
1132     // MED_DESCENDING
1133     // first polygon
1134     CPPUNIT_ASSERT_NO_THROW(ph1 = myNodalConnectivity.getConnectivityOfAnElement
1135                             (MED_EN::MED_DESCENDING, MED_EN::MED_FACE, /*Number*/1, len_ph1));
1136     CPPUNIT_ASSERT_EQUAL( 6, len_ph1 );
1137     const int edges1[6] = { 1,2,3,4,5,6 };
1138     CPPUNIT_ASSERT( vector<int>( edges1, edges1 + len_ph1 ) ==
1139                     vector<int>( ph1, ph1+len_ph1 ));
1140
1141     // second polygon
1142     CPPUNIT_ASSERT_NO_THROW(ph2 = myNodalConnectivity.getConnectivityOfAnElement
1143                             (MED_EN::MED_DESCENDING, MED_EN::MED_FACE, /*Number*/2, len_ph2));
1144     CPPUNIT_ASSERT_EQUAL( 4, len_ph2 );
1145     const int edges2[4] = { 7,8,9,-1 };
1146     CPPUNIT_ASSERT( vector<int>( edges2, edges2 + len_ph2 ) ==
1147                     vector<int>( ph2, ph2+len_ph2 ));
1148   }
1149
1150   ////////////
1151   // TEST 2 //
1152   ////////////
1153   checkCopyConnectivity();
1154
1155   ////////////
1156   // TEST 3 //
1157   ////////////
1158
1159   CONNECTIVITY *aCells1=new CONNECTIVITY(/*numberOfTypes*/2, /*Entity*/MED_EN::MED_CELL);
1160   CPPUNIT_ASSERT_EQUAL(MED_EN::MED_CELL, aCells1->getEntity());
1161   CPPUNIT_ASSERT_EQUAL(2, aCells1->getNumberOfTypes(MED_EN::MED_CELL));
1162   CPPUNIT_ASSERT_EQUAL(2, aCells1->getNumberOfTypes(MED_EN::MED_CELL));
1163
1164   CONNECTIVITY aCells2 (/*numberOfTypes*/3/*, Entity=MED_EN::MED_CELL*/);
1165   CPPUNIT_ASSERT_EQUAL(MED_EN::MED_CELL, aCells2.getEntity());
1166   CPPUNIT_ASSERT_EQUAL(3, aCells2.getNumberOfTypes(MED_EN::MED_CELL));
1167   CPPUNIT_ASSERT_EQUAL(3, aCells2.getNumberOfTypes(MED_EN::MED_CELL));
1168
1169   CONNECTIVITY * anEdges1 = new CONNECTIVITY(/*numberOfTypes*/1, /*Entity*/MED_EN::MED_EDGE);
1170   CPPUNIT_ASSERT_EQUAL(MED_EN::MED_EDGE, anEdges1->getEntity());
1171   CPPUNIT_ASSERT_EQUAL(1, anEdges1->getNumberOfTypes(MED_EN::MED_EDGE));
1172   CPPUNIT_ASSERT_EQUAL(1, anEdges1->getNumberOfTypes(MED_EN::MED_EDGE));
1173
1174   CONNECTIVITY * anEdges2 = new CONNECTIVITY(/*numberOfTypes*/2, /*Entity*/MED_EN::MED_EDGE);
1175   CPPUNIT_ASSERT_EQUAL(MED_EN::MED_EDGE, anEdges2->getEntity());
1176   CPPUNIT_ASSERT_EQUAL(2, anEdges2->getNumberOfTypes(MED_EN::MED_EDGE));
1177   CPPUNIT_ASSERT_EQUAL(2, anEdges2->getNumberOfTypes(MED_EN::MED_EDGE));
1178
1179   CONNECTIVITY * aFaces1 = new CONNECTIVITY(/*numberOfTypes*/2, /*Entity*/MED_EN::MED_FACE);
1180   CPPUNIT_ASSERT_EQUAL(MED_EN::MED_FACE, aFaces1->getEntity());
1181   CPPUNIT_ASSERT_EQUAL(2, aFaces1->getNumberOfTypes(MED_EN::MED_FACE));
1182   CPPUNIT_ASSERT_EQUAL(2, aFaces1->getNumberOfTypes(MED_EN::MED_FACE));
1183
1184   // No need to delete anEdges1 and aFaces1, because they are owned by aCells1
1185   // (anEdges1 is owned by aFaces1 to be precise)
1186   // No need to delete anEdges2, because they are owned by aCells2
1187
1188   // EntityDimension
1189   // It would be good to set EntityDimension automatically for EDGEs and FACEs,
1190   // and warn about not set EntityDimension for CELLs
1191   // (or calculate it by given geometric types)
1192   aCells1->setEntityDimension(3);
1193   aCells2.setEntityDimension(2); // for 2D mesh
1194   anEdges1->setEntityDimension(1);
1195   anEdges2->setEntityDimension(1);
1196   aFaces1->setEntityDimension(2);
1197
1198   CPPUNIT_ASSERT_EQUAL(3, aCells1->getEntityDimension());
1199   CPPUNIT_ASSERT_EQUAL(2, aCells2.getEntityDimension());
1200   CPPUNIT_ASSERT_EQUAL(1, anEdges1->getEntityDimension());
1201   CPPUNIT_ASSERT_EQUAL(1, anEdges2->getEntityDimension());
1202   CPPUNIT_ASSERT_EQUAL(2, aFaces1->getEntityDimension());
1203
1204   // getPolyTypeRelativeTo
1205   CPPUNIT_ASSERT_EQUAL(MED_EN::MED_POLYHEDRA, aCells1->getPolyTypeRelativeTo());
1206   CPPUNIT_ASSERT_EQUAL(MED_EN::MED_POLYGON  , aCells2.getPolyTypeRelativeTo());
1207   CPPUNIT_ASSERT_EQUAL(MED_EN::MED_POLYGON  , aFaces1->getPolyTypeRelativeTo());
1208   // because there is no poly types for edges (2D entities)
1209   CPPUNIT_ASSERT_THROW(anEdges1->getPolyTypeRelativeTo(), MEDEXCEPTION);
1210
1211   // setConstituent
1212   CPPUNIT_ASSERT_THROW(aCells1->setConstituent(&aCells2), MEDEXCEPTION);
1213   CPPUNIT_ASSERT_THROW(aCells1->setConstituent(anEdges1), MEDEXCEPTION);
1214
1215   aCells1->setConstituent(aFaces1);
1216   aCells1->setConstituent(anEdges1);
1217
1218   CPPUNIT_ASSERT_EQUAL(1, aCells1->getNumberOfTypes(MED_EN::MED_EDGE));
1219   CPPUNIT_ASSERT_EQUAL(2, aCells1->getNumberOfTypes(MED_EN::MED_FACE));
1220
1221   aCells2.setConstituent(anEdges2);
1222   CPPUNIT_ASSERT_EQUAL(2, aCells2.getNumberOfTypes(MED_EN::MED_EDGE));
1223
1224   // setGeometricTypes
1225   MED_EN::medGeometryElement aCellTypes2D[3] = {MED_EN::MED_TRIA3, MED_EN::MED_QUAD4, MED_EN::MED_TRIA6};
1226   MED_EN::medGeometryElement aCellTypes3D[2] = {MED_EN::MED_PYRA5, MED_EN::MED_HEXA8};
1227   MED_EN::medGeometryElement anEdgeTypes1[1] = {MED_EN::MED_SEG2};
1228   MED_EN::medGeometryElement anEdgeTypes2[2] = {MED_EN::MED_SEG2, MED_EN::MED_SEG3};
1229   MED_EN::medGeometryElement aFaceTypes2[2] =
1230     {MED_EN::MED_TRIA3, MED_EN::MED_QUAD4};
1231
1232   aCells1->setGeometricTypes(aCellTypes3D, MED_EN::MED_CELL);
1233   aCells1->setGeometricTypes(aFaceTypes2, MED_EN::MED_FACE);
1234   aCells1->setGeometricTypes(anEdgeTypes1, MED_EN::MED_EDGE);
1235   CPPUNIT_ASSERT_THROW(aCells1->setGeometricTypes(anEdgeTypes1, MED_EN::MED_NODE), MEDEXCEPTION);
1236
1237   aCells2.setGeometricTypes(aCellTypes2D, MED_EN::MED_CELL);
1238   anEdges2->setGeometricTypes(anEdgeTypes2, MED_EN::MED_EDGE);
1239   CPPUNIT_ASSERT_THROW(aCells2.setGeometricTypes(aFaceTypes2, MED_EN::MED_FACE), MEDEXCEPTION);
1240
1241   // setCount
1242   int countCell2D[4] = {1, 5, 6, 10};
1243   int countCell3D[3] = {1, 3, 4};
1244   int countEdges1[2] = {1, 21};
1245   int countEdges2[3] = {1, 13, 21};
1246   int countFaces1[3] = {1, 9, 15};
1247
1248   aCells1->setCount(countCell3D, MED_EN::MED_CELL);
1249   aCells1->setCount(countEdges1, MED_EN::MED_EDGE);
1250   aCells1->setCount(countFaces1, MED_EN::MED_FACE);
1251   CPPUNIT_ASSERT_THROW(aCells1->setCount(countEdges1, MED_EN::MED_NODE), MEDEXCEPTION);
1252
1253   aCells2.setCount(countCell2D, MED_EN::MED_CELL);
1254   aCells2.setCount(countEdges2, MED_EN::MED_EDGE);
1255   CPPUNIT_ASSERT_THROW(aCells2.setCount(countFaces1, MED_EN::MED_FACE), MEDEXCEPTION);
1256
1257   // setNodal
1258
1259   // aCells2
1260   int nodesCell2D_TRIA3[12] = {3,8,7, 10,7,13, 18,13,14, 11,14,8};
1261   int nodesCell2D_QUAD4[4] = {7,8,14,13};
1262   int nodesCell2D_TRIA6[24] = {1,2,3,7,10,6, 3,4,5,9,11,8, 11,15,20,19,18,14, 18,17,16,12,10,13};
1263
1264   aCells2.setNodal(nodesCell2D_TRIA3, MED_EN::MED_CELL, MED_EN::MED_TRIA3);
1265   aCells2.setNodal(nodesCell2D_QUAD4, MED_EN::MED_CELL, MED_EN::MED_QUAD4);
1266   aCells2.setNodal(nodesCell2D_TRIA6, MED_EN::MED_CELL, MED_EN::MED_TRIA6);
1267
1268   int nodesEdges2_SEG2[24] = {3,8, 8,11, 11,14, 14,18, 18,13, 13,10, 10,7,
1269                               7,3, 7,8, 8,14, 14,13, 13,7};
1270   int nodesEdges2_SEG3[24] = {1,2,3, 3,4,5, 5,9,11, 11,15,20,
1271                               20,19,18, 18,17,16, 16,12,10, 10,6,1};
1272
1273   aCells2.setNodal(nodesEdges2_SEG2, MED_EN::MED_EDGE, MED_EN::MED_SEG2);
1274   aCells2.setNodal(nodesEdges2_SEG3, MED_EN::MED_EDGE, MED_EN::MED_SEG3);
1275
1276   // aCells1
1277   int nodesCell3D_PYRA5[10] = {5,4,3,2,1, 6,7,8,9,10};
1278   int nodesCell3D_HEXA8[8] = {2,3,4,5, 6,7,8,9};
1279
1280   aCells1->setNodal(nodesCell3D_PYRA5, MED_EN::MED_CELL, MED_EN::MED_PYRA5);
1281   aCells1->setNodal(nodesCell3D_HEXA8, MED_EN::MED_CELL, MED_EN::MED_HEXA8);
1282
1283   int nodesFaces1_TRIA3[24] = {1,2,3, 1,3,4, 1,4,5, 1,5,2,
1284                                10,6,7, 10,7,8,  10,8,9, 10,9,6};
1285   int nodesFaces1_QUAD4[24] = {2,3,4,5, 6,7,8,9, 2,3,7,6, 5,4,8,9, 2,5,9,6, 3,4,8,7};
1286   // int nodesFaces1_TRIA6[6] = {11,12,13,14,15,16};
1287   // int nodesFaces1_QUAD8[8] = {15,14,13,17,18,19,20,21};
1288
1289   aCells1->setNodal(nodesFaces1_TRIA3, MED_EN::MED_FACE, MED_EN::MED_TRIA3);
1290   aCells1->setNodal(nodesFaces1_QUAD4, MED_EN::MED_FACE, MED_EN::MED_QUAD4);
1291   //aCells1->setNodal(nodesFaces1_TRIA6, MED_EN::MED_FACE, MED_EN::MED_TRIA6);
1292   //aCells1->setNodal(nodesFaces1_QUAD8, MED_EN::MED_FACE, MED_EN::MED_QUAD8);
1293
1294   int nodesEdges1_SEG2[40] = {1,2, 1,3, 1,4, 1,5, 10,6, 10,7, 10,8, 10,9,
1295                               2,3, 3,4, 4,5, 5,2,  6,7,  7,8,  8,9,  9,6,
1296                               2,6, 3,7, 4,8, 5,9};
1297
1298   aCells1->setNodal(nodesEdges1_SEG2, MED_EN::MED_EDGE, MED_EN::MED_SEG2);
1299
1300   // setNumberOfNodes
1301   aCells2.setNumberOfNodes(20);
1302   anEdges2->setNumberOfNodes(20);
1303
1304   aCells1->setNumberOfNodes(10);
1305   anEdges1->setNumberOfNodes(10);
1306   aFaces1->setNumberOfNodes(10);
1307
1308   // existConnectivity
1309   CPPUNIT_ASSERT(aCells1->existConnectivity(MED_EN::MED_NODAL, MED_EN::MED_CELL));
1310   CPPUNIT_ASSERT(aCells1->existConnectivity(MED_EN::MED_NODAL, MED_EN::MED_FACE));
1311   CPPUNIT_ASSERT(aCells1->existConnectivity(MED_EN::MED_NODAL, MED_EN::MED_EDGE));
1312   CPPUNIT_ASSERT(!aCells1->existConnectivity(MED_EN::MED_NODAL, MED_EN::MED_NODE));
1313
1314   CPPUNIT_ASSERT(!aCells1->existConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_CELL));
1315   CPPUNIT_ASSERT(!aCells1->existConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_FACE));
1316   CPPUNIT_ASSERT(!aCells1->existConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_EDGE));
1317   CPPUNIT_ASSERT(!aCells1->existConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_NODE));
1318
1319   CPPUNIT_ASSERT(aCells2.existConnectivity(MED_EN::MED_NODAL, MED_EN::MED_CELL));
1320   CPPUNIT_ASSERT(!aCells2.existConnectivity(MED_EN::MED_NODAL, MED_EN::MED_FACE));
1321   CPPUNIT_ASSERT(aCells2.existConnectivity(MED_EN::MED_NODAL, MED_EN::MED_EDGE));
1322   CPPUNIT_ASSERT(!aCells2.existConnectivity(MED_EN::MED_NODAL, MED_EN::MED_NODE));
1323
1324   CPPUNIT_ASSERT(!aCells2.existConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_CELL));
1325   CPPUNIT_ASSERT(!aCells2.existConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_FACE));
1326   CPPUNIT_ASSERT(!aCells2.existConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_EDGE));
1327   CPPUNIT_ASSERT(!aCells2.existConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_NODE));
1328
1329   // getConnectivityOfAnElement
1330   {
1331     int len_e1, len_e2, i;
1332     const int * nc_e1 = aCells1->getConnectivityOfAnElement
1333       (MED_EN::MED_NODAL, MED_EN::MED_CELL, /*Number*/1, len_e1);
1334     CPPUNIT_ASSERT_EQUAL(5, len_e1); // PYRA5 {1,2,3,4,5}
1335     for (i = 0; i < len_e1; i++) {
1336       if (nc_e1[i] < 1 || 5 < nc_e1[i])
1337         CPPUNIT_FAIL("Wrong node in element");
1338     }
1339
1340     const int * nc_e2 = aCells2.getConnectivityOfAnElement
1341       (MED_EN::MED_NODAL, MED_EN::MED_CELL, /*Number*/2, len_e2);
1342     CPPUNIT_ASSERT_EQUAL(3, len_e2); // TRIA3 {7,10,13}
1343     for (i = 0; i < len_e2; i++) {
1344       if (nc_e2[i] != 7 && nc_e2[i] != 10 && nc_e2[i] != 13)
1345         CPPUNIT_FAIL("Wrong node in element");
1346     }
1347   }
1348
1349   //  aCells1 (2 types)  |
1350   //     |               |
1351   //  aFaces1 (4 types)  |  aCells2 (3 types)
1352   //     |               |     |
1353   //  anEdges1 (1 type)  |  anEdges2 (2 types)
1354
1355   MESH* mesh=new MESH; //updateFamily method requires a pointer to the mesh
1356   mesh->setConnectivityptr(aCells1);
1357   // updateFamily
1358   {
1359     FAMILY *aFamilyOnFaces=new FAMILY;
1360     aFamilyOnFaces->setEntity(MED_EN::MED_FACE);
1361     aFamilyOnFaces->setMeshName("Mesh 1");
1362     aFamilyOnFaces->setMesh(mesh);
1363     mesh->removeReference();
1364     aFamilyOnFaces->setName("Support On Faces 1");
1365     //aFamilyOnFaces->setAll(true);
1366
1367     int nbTypesFam1 = 2;
1368     MED_EN::medGeometryElement aSCTypes[4] = {MED_EN::MED_TRIA3, MED_EN::MED_QUAD4};
1369     int nbEltsSC[4] = {8,6};
1370     int indexSC[5] = {1,9,15}; // length = nb.types + 1
1371     int valueSC[16] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14}; // length = total nb. of elements
1372     //int nbTypesFam1 = 1;
1373     //MED_EN::medGeometryElement aSCTypes[1] = {MED_EN::MED_TRIA3};
1374     //int nbEltsSC[1] = {8};
1375     //int indexSC[2] = {1,9}; // length = nb.types + 1
1376     //int valueSC[8] = {1,3,5,7,9,11,13,15}; // length = total nb. of elements
1377
1378     aFamilyOnFaces->setNumberOfGeometricType(nbTypesFam1);
1379     aFamilyOnFaces->setGeometricType(aSCTypes);
1380     aFamilyOnFaces->setNumberOfElements(nbEltsSC);
1381     aFamilyOnFaces->setNumber(indexSC, valueSC);
1382
1383     vector<FAMILY*> aFamsOnFaces (1);
1384     aFamsOnFaces[0] = aFamilyOnFaces;
1385
1386     // Attention!!! By default ENABLE_UPDATE_FAMILY is not defined!!!
1387     // I do not undestand, what this method should do
1388     // and what I must give to it to obtain good result
1389
1390     CPPUNIT_ASSERT_NO_THROW(aCells1->updateFamily(aFamsOnFaces));
1391     aFamilyOnFaces->removeReference();
1392   }
1393
1394   ////////////
1395   // TEST 4 //
1396   ////////////
1397   CONNECTIVITY * c1 = new CONNECTIVITY(/*numberOfTypes*/3, MED_EN::MED_CELL);
1398   createOrCheck(c1, "Creation", /*create*/true);
1399   createOrCheck(c1, "Check just created", /*create*/false);
1400
1401   CONNECTIVITY * c2 = new CONNECTIVITY(*c1);
1402   createOrCheck(c2, "Check copy constructor", /*create*/false);
1403
1404   // invertConnectivityForAFace
1405   int nbFacesC2 = c2->getNumberOf(MED_EN::MED_FACE, MED_EN::MED_ALL_ELEMENTS);
1406   for (int faceId = 1; faceId <= nbFacesC2; faceId++) {
1407
1408     // this face nodal connectivity before inversion:
1409     int oldLen, newLen;
1410     const int * oldConn = c2->getConnectivityOfAnElement(MED_EN::MED_NODAL,
1411                                                          MED_EN::MED_FACE, faceId, oldLen);
1412
1413     // descending connectivity before inversion:
1414     int before_NumberOfElements = c2->getNumberOf(MED_EN::MED_CELL, MED_EN::MED_ALL_ELEMENTS);
1415     const int * before_connectivity_shared =
1416       c2->getConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_CELL, MED_EN::MED_ALL_ELEMENTS);
1417     const int * before_connectivity_index =
1418       c2->getConnectivityIndex(MED_EN::MED_DESCENDING, MED_EN::MED_CELL);
1419
1420     // copy connectivity, because the pointer, returned by getConnectivity,
1421     // will point to the same memory before and after inversion
1422     int lenDC = before_connectivity_index[before_NumberOfElements] - 1;
1423     int * before_connectivity = new int[lenDC];
1424     for (int i = 0; i < lenDC; i++)
1425       before_connectivity[i] = before_connectivity_shared[i];
1426
1427     // reverse descending connectivity before inversion:
1428     const int * before_ReverseDescendingConnectivity_shared =
1429       c2->getReverseConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_CELL);
1430     const int * before_ReverseDescendingConnectivityIndex =
1431       c2->getReverseConnectivityIndex(MED_EN::MED_DESCENDING, MED_EN::MED_CELL);
1432
1433     int lenRDC = before_ReverseDescendingConnectivityIndex[nbFacesC2] - 1;
1434     int * before_ReverseDescendingConnectivity = new int[lenRDC];
1435     for (int i = 0; i < lenRDC; i++)
1436       before_ReverseDescendingConnectivity[i] = before_ReverseDescendingConnectivity_shared[i];
1437
1438     // perform inversion
1439     int * newNodesForFace = new int[oldLen];
1440     if (oldLen == 3) {
1441       newNodesForFace[0] = oldConn[1];
1442       newNodesForFace[1] = oldConn[0];
1443       newNodesForFace[2] = oldConn[2];
1444     } else {
1445       newNodesForFace[0] = oldConn[2];
1446       newNodesForFace[1] = oldConn[1];
1447       newNodesForFace[2] = oldConn[0];
1448       newNodesForFace[3] = oldConn[3];
1449     }
1450     c2->invertConnectivityForAFace(faceId, newNodesForFace);
1451
1452     // reverse descending connectivity after inversion:
1453     const int * after_ReverseDescendingConnectivity =
1454       c2->getReverseConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_CELL);
1455     const int * after_ReverseDescendingConnectivityIndex =
1456       c2->getReverseConnectivityIndex(MED_EN::MED_DESCENDING, MED_EN::MED_CELL);
1457
1458     // Faces, which are on bound (have one neighbouring), are not inverted.
1459     bool isOnBound = false;
1460
1461     for (int i = 0; i < nbFacesC2; i++) {
1462       int plus = after_ReverseDescendingConnectivityIndex[i] - 1;
1463       // always two neighbourings
1464       if ((i + 1) == faceId) {
1465         // no second neighbouring
1466         isOnBound = (before_ReverseDescendingConnectivity[plus + 1] == 0);
1467       }
1468       if ((i + 1) == faceId && !isOnBound) {
1469         CPPUNIT_ASSERT_EQUAL(before_ReverseDescendingConnectivity[plus + 0],
1470                              after_ReverseDescendingConnectivity[plus + 1]);
1471         CPPUNIT_ASSERT_EQUAL(before_ReverseDescendingConnectivity[plus + 1],
1472                              after_ReverseDescendingConnectivity[plus + 0]);
1473       }
1474       else {
1475         CPPUNIT_ASSERT_EQUAL(before_ReverseDescendingConnectivity[plus + 0],
1476                              after_ReverseDescendingConnectivity[plus + 0]);
1477         CPPUNIT_ASSERT_EQUAL(before_ReverseDescendingConnectivity[plus + 1],
1478                              after_ReverseDescendingConnectivity[plus + 1]);
1479       }
1480     }
1481
1482     // descending connectivity after inversion:
1483     int after_NumberOfElements = c2->getNumberOf(MED_EN::MED_CELL, MED_EN::MED_ALL_ELEMENTS);
1484     const int * after_connectivity =
1485       c2->getConnectivity(MED_EN::MED_DESCENDING, MED_EN::MED_CELL, MED_EN::MED_ALL_ELEMENTS);
1486     const int * after_connectivity_index =
1487       c2->getConnectivityIndex(MED_EN::MED_DESCENDING, MED_EN::MED_CELL);
1488
1489     CPPUNIT_ASSERT_EQUAL(before_NumberOfElements, after_NumberOfElements);
1490
1491     for (int j = 0; j < before_NumberOfElements; j++) {
1492       for (int k = after_connectivity_index[j]; k < after_connectivity_index[j+1]; k++) {
1493         if (labs(before_connectivity[k-1]) == faceId && !isOnBound) {
1494           CPPUNIT_ASSERT_EQUAL(before_connectivity[k-1], - after_connectivity[k-1]);
1495         }
1496         else {
1497           CPPUNIT_ASSERT_EQUAL(before_connectivity[k-1], after_connectivity[k-1]);
1498         }
1499       }
1500     }
1501
1502     // this face nodal connectivity after inversion:
1503     if (!isOnBound) {
1504       const int * newConn = c2->getConnectivityOfAnElement(MED_EN::MED_NODAL,
1505                                                            MED_EN::MED_FACE, faceId, newLen);
1506       CPPUNIT_ASSERT_EQUAL(oldLen, newLen);
1507       for (int i = 0; i < newLen && i < 4; i++) {
1508         CPPUNIT_ASSERT_EQUAL(newNodesForFace[i], newConn[i]);
1509       }
1510     }
1511     delete [] newNodesForFace;
1512
1513     delete [] before_connectivity;
1514     delete [] before_ReverseDescendingConnectivity;
1515
1516     // ATTENTION: invertConnectivityForAFace() is not tested on polygons!!!
1517   }
1518
1519
1520   delete c1;
1521   delete c2;
1522 }