9 #include "MEDMEM_STRING.hxx"
10 #include "MEDMEM_Exception.hxx"
11 #include "MEDMEM_define.hxx"
13 //#include "MEDMEM_Support.hxx"
14 #include "MEDMEM_Coordinate.hxx"
15 #include "MEDMEM_Connectivity.hxx"
17 // Add your own driver header (step 2)
18 #include "MEDMEM_MedMeshDriver.hxx"
19 #include "MEDMEM_MedMedDriver.hxx"
20 #include "MEDMEM_GibiMeshDriver.hxx"
21 #include "MEDMEM_PorflowMeshDriver.hxx"
23 #include "MEDMEM_VtkMeshDriver.hxx"
28 //class MED_MESH_RDONLY_DRIVER;
29 //class MED_MESH_WRONLY_DRIVER;
31 using namespace MED_EN;
33 /*! This class contains all the informations related with a MESH :
41 NOTE: A Family is only on one type of entity (MED_CELL, MED_FACE, MED_EDGE, MED_NODE).
42 You can't have a family on MED_CELL and MED_FACE
48 template <class T> class FIELD;
61 // ------- Drivers Management Part
64 //-----------------------//
66 //-----------------------//
69 virtual GENDRIVER * run(const string & fileName, MESH * ptrMesh) const = 0;
72 //-------------------------------------------------------//
73 template <class T> class INSTANCE_DE : public INSTANCE
74 //-------------------------------------------------------//
77 GENDRIVER * run(const string & fileName, MESH * ptrMesh) const
78 { return new T(fileName,ptrMesh); }
81 // Add a similar line for your personnal driver (step 3)
83 static INSTANCE_DE<MED_MESH_RDWR_DRIVER> inst_med;
84 static INSTANCE_DE<GIBI_MESH_RDWR_DRIVER> inst_gibi;
85 static INSTANCE_DE<PORFLOW_MESH_RDWR_DRIVER> inst_porflow;
86 static INSTANCE_DE<VTK_MESH_DRIVER> inst_vtk;
88 //static INSTANCE_DE<VTK_DRIVER> inst_vtk ;
89 static const INSTANCE * const instances[];
91 // ------ End of Drivers Management Part
94 //-----------------------//
96 //-----------------------//
100 string _name; // A POSITIONNER EN FCT DES IOS ?
102 mutable COORDINATE * _coordinate;
103 mutable CONNECTIVITY * _connectivity;
110 //////////////////////////////////////////////////////////////////////////////////////
111 /// Modification pour prise en compte de la numérotation optionnelle des noeuds ///
112 //////////////////////////////////////////////////////////////////////////////////////
114 /// La map suivante donne le lien numérotation optionnelle => numérotation cannonique
115 /// Elle sera calculée apres l'appel de MEDnumLire(...)
116 /// Et sera utilisée avant chaque appel a MEDconnLire(...) pour renuméroter toutes les mailles de façon canonique [1...n]
117 /// _coordinate->NodeNumber sera utilisé avant chaque appel à MEDconnEcri pour démunéroter les mailles en leur numérotation originelle
118 /// Ce traitement devrait prévenir tout plantage du aux numérotations optionnelles DES NOEUDS
119 /// Et ne ralentira que tres peu les traitements sans numéros optionnels
121 int _arePresentOptionnalNodesNumbers;
122 map<int,int> _optionnalToCanonicNodesNumbers;
124 vector<FAMILY*> _familyNode;
125 vector<FAMILY*> _familyCell;
126 vector<FAMILY*> _familyFace;
127 vector<FAMILY*> _familyEdge;
129 vector<GROUP*> _groupNode;
130 vector<GROUP*> _groupCell;
131 vector<GROUP*> _groupFace;
132 vector<GROUP*> _groupEdge;
135 vector<GENDRIVER *> _drivers; // Storage of the drivers currently in use
137 bool _isAGrid; // am I a GRID or not
139 //-----------------------//
141 //-----------------------//
143 // inline void checkGridFillCoords() const;
144 // inline void checkGridFillConnectivity() const;
145 bool isEmpty() const;
146 // if this->_isAGrid, assure that _coordinate and _connectivity are filled
150 // Add your personnal driver line (step 2)
151 friend class MED_MESH_RDONLY_DRIVER;
152 friend class MED_MESH_WRONLY_DRIVER;
154 friend class MED_MED_RDONLY_DRIVER;
155 friend class MED_MED_WRONLY_DRIVER;
156 friend class MED_MED_RDWR_DRIVER;
158 friend class GIBI_MESH_RDONLY_DRIVER;
159 friend class GIBI_MESH_WRONLY_DRIVER;
160 friend class GIBI_MESH_RDWR_DRIVER;
162 friend class PORFLOW_MESH_RDONLY_DRIVER;
163 friend class PORFLOW_MESH_WRONLY_DRIVER;
164 friend class PORFLOW_MESH_RDWR_DRIVER;
166 friend class VTK_MESH_DRIVER;
171 MESH & operator=(const MESH &m);
172 MESH( driverTypes driverType, const string & fileName="",
173 const string & meshName="") throw (MEDEXCEPTION);
175 friend ostream & operator<<(ostream &os, const MESH &my);
177 int addDriver(driverTypes driverType,
178 const string & fileName ="Default File Name.med",
179 const string & driverName="Default Mesh Name");
180 int addDriver(GENDRIVER & driver);
181 void rmDriver(int index=0);
183 virtual void read(int index=0);
184 inline void read(const MED_MED_DRIVER & genDriver);
185 inline void write(int index=0, const string & driverName = "");
186 inline void write(const MED_MED_DRIVER & genDriver);
188 // void calculateReverseConnectivity();
189 // void createFaces(); //Faces creation => full constituent informations
190 // void buildConstituent(); // calculate descendent connectivity + face-cell connectivity
193 inline void setName(string name);
195 inline string getName() const;
196 inline int getSpaceDimension() const;
197 inline int getMeshDimension() const;
198 inline bool getIsAGrid();
200 inline int getNumberOfNodes() const;
201 virtual inline const COORDINATE * getCoordinateptr() const;
202 inline string getCoordinatesSystem() const;
203 virtual inline const double * getCoordinates(medModeSwitch Mode) const;
204 virtual inline const double getCoordinate(int Number,int Axis) const;
205 inline const string * getCoordinatesNames() const;
206 inline const string * getCoordinatesUnits() const;
207 //inline int * getNodesNumbers();
209 virtual inline int getNumberOfTypes(medEntityMesh Entity) const;
210 virtual inline const medGeometryElement * getTypes(medEntityMesh Entity) const;
211 virtual inline const CELLMODEL * getCellsTypes(medEntityMesh Entity) const;
212 virtual const int * getGlobalNumberingIndex(medEntityMesh Entity) const;
213 virtual inline int getNumberOfElements(medEntityMesh Entity,
214 medGeometryElement Type) const;
215 virtual inline bool existConnectivity(medConnectivity ConnectivityType,
216 medEntityMesh Entity) const;
218 virtual inline medGeometryElement getElementType(medEntityMesh Entity,
220 virtual inline void calculateConnectivity(medModeSwitch Mode,
221 medConnectivity ConnectivityType,
222 medEntityMesh Entity) const ;
223 virtual inline const int * getConnectivity(medModeSwitch Mode,
224 medConnectivity ConnectivityType,
225 medEntityMesh Entity,
226 medGeometryElement Type) const;
227 virtual inline const int * getConnectivityIndex(medConnectivity ConnectivityType,
228 medEntityMesh Entity) const;
229 virtual int getElementNumber(medConnectivity ConnectivityType,
230 medEntityMesh Entity,
231 medGeometryElement Type,
232 int * connectivity) const;
234 virtual inline const int * getReverseConnectivity(medConnectivity ConnectivityType,
235 medEntityMesh Entity=MED_CELL) const;
236 virtual inline const int * getReverseConnectivityIndex(medConnectivity ConnectivityType,
237 medEntityMesh Entity=MED_CELL) const;
239 virtual int getNumberOfFamilies(medEntityMesh Entity) const;
240 virtual inline const vector<FAMILY*> getFamilies(medEntityMesh Entity) const;
241 virtual inline const FAMILY* getFamily(medEntityMesh Entity,int i) const;
242 virtual int getNumberOfGroups(medEntityMesh Entity) const;
243 virtual inline const vector<GROUP*> getGroups(medEntityMesh Entity) const;
244 virtual inline const GROUP* getGroup(medEntityMesh Entity,int i) const;
245 virtual inline const CONNECTIVITY* getConnectivityptr() const;
246 virtual SUPPORT * getBoundaryElements(medEntityMesh Entity)
247 throw (MEDEXCEPTION);
248 // problème avec le maillage dans le support :
249 // le pointeur n'est pas const, mais sa valeur oui. A voir !!! PG
251 SUPPORT * getSkin(const SUPPORT * Support3D)
252 throw (MEDEXCEPTION);
254 // Node DonneBarycentre(const Cell &m) const;
255 virtual FIELD<double>* getVolume (const SUPPORT * Support) const
256 throw (MEDEXCEPTION);
257 // Support must be on 3D elements
258 virtual FIELD<double>* getArea (const SUPPORT * Support) const
259 throw (MEDEXCEPTION);
260 // Support must be on 2D elements
261 virtual FIELD<double>* getLength (const SUPPORT * Support) const
262 throw (MEDEXCEPTION);
263 // Support must be on 1D elements
264 virtual FIELD<double>* getNormal (const SUPPORT * Support) const
265 throw (MEDEXCEPTION);
266 // Support must be on 2D elements
267 virtual FIELD<double>* getBarycenter (const SUPPORT * Support) const
268 throw (MEDEXCEPTION);
269 // FIELD<int>* getNeighbourhood(SUPPORT * Support) const
270 // throw (MEDEXCEPTION); // Il faut preciser !
273 return a SUPPORT pointer on the union of all SUPPORTs in Supports.
274 You should delete this pointer after use to avois memory leaks.
276 SUPPORT * mergeSupports(const vector<SUPPORT *> Supports) const throw (MEDEXCEPTION) ;
279 return a SUPPORT pointer on the intersection of all SUPPORTs in Supports.
280 The (SUPPORT *) NULL pointer is returned if the intersection is empty.
281 You should delete this pointer after use to avois memory leaks.
283 SUPPORT * intersectSupports(const vector<SUPPORT *> Supports) const throw (MEDEXCEPTION) ;
286 * Create families from groups.
287 * This function is automaticaly called whenever we ask for families that are not up-to-date.
288 * (The creation of families is delayed to the need of user.)
289 * If a new created family hapen to already exist, we keep the old one.
290 * (There is no way to know which family has change.)
292 void createFamilies();
296 using namespace MEDMEM;
297 // ---------------------------------------
299 // ---------------------------------------
301 inline const CONNECTIVITY* MESH::getConnectivityptr() const
303 // checkGridFillConnectivity();
304 return _connectivity;
307 // inline void MESH::read(int index/*=0*/)
309 // const char * LOC = "MESH::read(int index=0) : ";
312 // if (_drivers[index]) {
313 // _drivers[index]->open();
314 // _drivers[index]->read();
315 // _drivers[index]->close();
318 // throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
319 // << "The index given is invalid, index must be between 0 and |"
320 // << _drivers.size()
326 /*! Write all the content of the MESH using driver referenced by the integer handler index.*/
327 inline void MESH::write(int index/*=0*/, const string & driverName/* = ""*/)
329 const char * LOC = "MESH::write(int index=0, const string & driverName = \"\") : ";
332 if ( _drivers[index] ) {
333 _drivers[index]->open();
334 if (driverName != "") _drivers[index]->setMeshName(driverName);
335 _drivers[index]->write();
336 _drivers[index]->close();
339 throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
340 << "The index given is invalid, index must be between 0 and |"
347 // This method is MED specific : don't use it
349 inline void MESH::write(const MED_MED_DRIVER & genDriver)
351 const char * LOC = "MESH::write(const MED_MED_DRIVER & genDriver): ";
354 for (unsigned int index=0; index < _drivers.size(); index++ )
355 if ( *_drivers[index] == genDriver ) {
356 _drivers[index]->open();
357 _drivers[index]->write();
358 _drivers[index]->close();
359 // ? FINALEMENT PAS BESOIN DE L'EXCEPTION ?
366 // This method is MED specific : don't use it
368 inline void MESH::read(const MED_MED_DRIVER & genDriver)
370 const char * LOC = "MESH::read(const MED_MED_DRIVER & genDriver): ";
373 for (unsigned int index=0; index < _drivers.size(); index++ )
374 if ( *_drivers[index] == genDriver ) {
375 _drivers[index]->open();
376 _drivers[index]->read();
377 _drivers[index]->close();
378 // ? FINALEMENT PAS BESOIN DE L'EXCEPTION ?
385 /*! Set the MESH name */
386 inline void MESH::setName(string name)
388 _name=name; //NOM interne à la classe
391 /*! Get the MESH name */
392 inline string MESH::getName() const
397 /*! Get the dimension of the space */
398 inline int MESH::getSpaceDimension() const
400 return _spaceDimension;
403 /*! Get the dimension of the MESH */
404 inline int MESH::getMeshDimension() const
406 return _meshDimension;
409 /*! Get the number of nodes used in the MESH */
410 inline int MESH::getNumberOfNodes() const
412 return _numberOfNodes;
415 /*! Get the COORDINATES object. Use it only if you need COORDINATES informations not provided by the MESH class.*/
416 inline const COORDINATE * MESH::getCoordinateptr() const
418 // checkGridFillCoords();
422 /*! Get the system in which coordinates are given (CARTESIAN,CYLINDRICAL,SPHERICAL) __??MED_CART??__. */
423 inline string MESH::getCoordinatesSystem() const
425 return _coordinate->getCoordinatesSystem();
428 /*! Get the whole coordinates array in a given interlacing mode. The interlacing mode are :
429 - MED_NO_INTERLACE : X1 X2 Y1 Y2 Z1 Z2
430 - MED_FULL_INTERLACE : X1 Y1 Z1 X2 Y2 Z2
432 inline const double * MESH::getCoordinates(medModeSwitch Mode) const
434 // checkGridFillCoords();
435 return _coordinate->getCoordinates(Mode);
438 /*! Get the coordinate n° number on axis n°axis*/
439 inline const double MESH::getCoordinate(int number, int axis) const
441 // checkGridFillCoords();
442 return _coordinate->getCoordinate(number,axis);
445 /*! Get the coordinate names array ("x ","y ","z ")
446 of size n*MED_TAILLE_PNOM
448 inline const string * MESH::getCoordinatesNames() const
450 return _coordinate->getCoordinatesNames();
453 /*! Get the coordinate unit names array ("cm ","cm ","cm ")
454 of size n*MED_TAILLE_PNOM
456 inline const string * MESH::getCoordinatesUnits() const
458 return _coordinate->getCoordinatesUnits();
460 // int * MESH::getNodesNumbers() const
462 // return nodesNumbers;
465 /*! Get the number of different geometric types for a given entity type.
467 For exemple getNumberOfTypes(MED_CELL) would return 3 if the MESH
468 have some MED_TETRA4, MED_PYRA5 and MED_HEXA6 in it.
470 medEntityMesh entity : MED_CELL, MED_FACE, MED_EDGE, MED_NODE, MED_ALL_ENTITIES
472 If entity is not defined, return 0.
474 If there is no connectivity, return an exception.
476 inline int MESH::getNumberOfTypes(medEntityMesh entity) const
478 MESSAGE("MESH::getNumberOfTypes(medEntityMesh entity) : "<<entity);
479 if (entity == MED_NODE)
481 // checkGridFillConnectivity();
482 if (_connectivity != NULL)
483 return _connectivity->getNumberOfTypes(entity);
484 throw MEDEXCEPTION(LOCALIZED("MESH::getNumberOfTypes( medEntityMesh ) : Connectivity not defined !"));
488 Get the list of geometric types used by a given entity.
489 medEntityMesh entity : MED_CELL, MED_FACE, MED_EDGE, MED_ALL_ENTITIES
491 REM : Don't use MED_NODE
493 If entity is not defined, return an exception.
495 inline const medGeometryElement * MESH::getTypes(medEntityMesh entity) const
497 if (entity == MED_NODE)
498 throw MEDEXCEPTION(LOCALIZED("MESH::getTypes( medEntityMesh ) : No medGeometryElement with MED_NODE entity !"));
499 // return un tableau de taille 1 contenant MED_NONE, comme les supports pour etre coherent avec getNumberOfTypes ???? PG
501 // checkGridFillConnectivity();
502 if (_connectivity != NULL)
503 return _connectivity->getGeometricTypes(entity);
504 throw MEDEXCEPTION(LOCALIZED("MESH::getTypes( medEntityMesh ) : Connectivity not defined !"));
508 Get the whole list of CELLMODEL used by cells of given type (medEntityMesh).
510 REMARK : Don't use MED_NODE as medEntityMesh
512 inline const CELLMODEL * MESH::getCellsTypes(medEntityMesh Entity) const
514 // checkGridFillConnectivity();
515 if (_connectivity != NULL)
516 return _connectivity->getCellsTypes(Entity);
517 throw MEDEXCEPTION(LOCALIZED("MESH::getCellsTypes( medEntityMesh ) : Connectivity not defined !"));
520 /*! Return an array of size NumbreOfTypes+1 which contains, for each
521 geometric type of the given entity, the first global element number
524 For exemple, if we have a mesh with 5 triangles and 4 quadrangle :
525 - size of GlobalNumberingIndex is 3
526 - GlobalNumberingIndex[0]=1 (the first type)
527 - GlobalNumberingIndex[1]=6 (the second type)
528 - GlobalNumberingIndex[2]=10
530 inline const int * MESH::getGlobalNumberingIndex(medEntityMesh entity) const
532 // checkGridFillConnectivity();
533 if (_connectivity != NULL)
534 return _connectivity->getGlobalNumberingIndex(entity);
535 throw MEDEXCEPTION(LOCALIZED("MESH::getNumberOfTypes( medEntityMesh ) : Connectivity not defined !"));
538 Return the number of element of given geometric type of given entity. Return 0 if query is not defined.
541 - getNumberOfElements(MED_NODE,MED_NONE) : number of node
542 - getNumberOfElements(MED_NODE,MED_TRIA3) : return 0 (not defined)
543 - getNumberOfElements(MED_FACE,MED_TRIA3) : return number of triangles
544 elements defined in face entity (0 if not defined)
545 - getNumberOfElements(MED_CELL,MED_ALL_ELEMENTS) : return total number
546 of elements defined in cell entity
548 inline int MESH::getNumberOfElements(medEntityMesh entity, medGeometryElement Type) const
550 // const char * LOC = "MESH::getNumberOfElements(medEntityMesh,medGeometryElement) : ";
551 if (entity==MED_NODE)
552 if ((Type==MED_NONE)|(Type==MED_ALL_ELEMENTS))
553 return _numberOfNodes;
556 //throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"wrong medGeometryElement with MED_NODE"));
559 // checkGridFillConnectivity();
560 if (_connectivity != (CONNECTIVITY*)NULL)
561 return _connectivity->getNumberOf(entity,Type);
564 //throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"connectivity not defined !"));
568 Return true if the wanted connectivity exist, else return false
569 (to use before a getSomething method).
571 inline bool MESH::existConnectivity(medConnectivity connectivityType, medEntityMesh entity) const
573 // checkGridFillConnectivity();
574 if (_connectivity==(CONNECTIVITY*)NULL)
575 throw MEDEXCEPTION("MESH::existConnectivity(medConnectivity,medEntityMesh) : no connectivity defined !");
576 return _connectivity->existConnectivity(connectivityType,entity);
579 Return the geometric type of global element Number of entity Entity.
581 Throw an exception if Entity is not defined or Number are wrong (too big).
583 inline medGeometryElement MESH::getElementType(medEntityMesh Entity,int Number) const
585 // checkGridFillConnectivity();
586 if (_connectivity==(CONNECTIVITY*)NULL)
587 throw MEDEXCEPTION("MESH::getElementType(medEntityMesh,int) : no connectivity defined !");
588 return _connectivity->getElementType(Entity,Number);
591 Calculate the ask connectivity. Return an exception if this could not be
592 done. Do nothing if connectivity already exist.
595 inline void MESH::calculateConnectivity(medModeSwitch Mode,medConnectivity ConnectivityType,medEntityMesh entity) const
597 // checkGridFillConnectivity();
598 if (Mode==MED_FULL_INTERLACE)
599 _connectivity->calculateConnectivity(ConnectivityType,entity);
601 throw MEDEXCEPTION(LOCALIZED("MESH::calculateConnectivity : only for MED_FULL_INTERLACE mode"));
604 Return the required connectivity in the right mode for the given
605 geometric type of the given entity.
607 To get connectivity for all geometric type, use Mode=MED_FULL_INTERLACE
608 and Type=MED_ALL_ELEMENTS.
609 You must also get the corresponding index array.
611 inline const int * MESH::getConnectivity(medModeSwitch Mode,medConnectivity ConnectivityType,medEntityMesh entity, medGeometryElement Type) const
613 // checkGridFillConnectivity();
614 if (Mode==MED_FULL_INTERLACE)
615 return _connectivity->getConnectivity(ConnectivityType,entity,Type);
616 throw MEDEXCEPTION(LOCALIZED("MESH::getConnectivity : only for MED_FULL_INTERLACE mode"));
619 Return the required index array for a connectivity received in
620 MED_FULL_ENTERLACE mode and MED_ALL_ELEMENTS type.
622 This array allow to find connectivity of each elements.
624 Example : Connectivity of i^{th} elements (1<=i<=NumberOfElement) begin
625 at index ConnectivityIndex[i-1] and end at index ConnectivityIndex[i]-1
626 in Connectivity array (Connectivity[ConnectivityIndex[i-1]-1] is the
629 inline const int * MESH::getConnectivityIndex(medConnectivity ConnectivityType,medEntityMesh entity) const
631 // checkGridFillConnectivity();
632 return _connectivity->getConnectivityIndex(ConnectivityType, entity);
635 Return the reverse connectivity required by ConnectivityType :
636 - If ConnectivityType=MED_NODAL : return connectivity node-cell
637 - If ConnectivityType=MED_DESCENDING : return connectivity face-cell
639 You must get ReverseConnectivityIndex array to use it.
641 inline const int * MESH::getReverseConnectivity(medConnectivity ConnectivityType,medEntityMesh Entity/*=MED_CELL*/) const
643 // checkGridFillConnectivity();
644 if (NULL==_connectivity)
645 throw MEDEXCEPTION("MESH::getReverseConnectivity : no connectivity defined in MESH !");
647 return _connectivity->getReverseConnectivity(ConnectivityType,Entity);
650 Return the index array required by ConnectivityType.
652 This array allow to find reverse connectivity of each elements.
654 Example : Reverse connectivity of i^{th} elements (1<=i<=NumberOfElement)
655 begin at index ReverseConnectivityIndex[i-1] and end at index
656 ReverseConnectivityIndex[i]-1
657 in ReverseConnectivity array (
658 ReverseConnectivity[ReverseConnectivityIndex[i-1]-1]
661 inline const int * MESH::getReverseConnectivityIndex(medConnectivity ConnectivityType,medEntityMesh Entity/*=MED_CELL*/) const
663 // checkGridFillConnectivity();
664 if (NULL==_connectivity)
665 throw MEDEXCEPTION("MESH::getReverseConnectivityIndex : no connectivity defined in MESH !");
667 return _connectivity->getReverseConnectivityIndex(ConnectivityType,Entity);
671 inline int MESH::getNumberOfFamilies (medEntityMesh entity) const
675 return _familyNode.size();
677 return _familyCell.size();
679 return _familyFace.size();
681 return _familyEdge.size();
683 throw MEDEXCEPTION("MESH::getNumberOfFamilies : Unknown entity");
686 inline int MESH::getNumberOfGroups (medEntityMesh entity) const
690 return _groupNode.size();
692 return _groupCell.size();
694 return _groupFace.size();
696 return _groupEdge.size();
698 throw MEDEXCEPTION("MESH::getNumberOfGroups : Unknown entity");
701 const vector<MEDMEM::FAMILY*> MESH::getFamilies(medEntityMesh entity) const
713 throw MEDEXCEPTION("MESH::getFamilies : Unknown entity");
717 const vector<GROUP*> MESH::getGroups(medEntityMesh entity) const
729 throw MEDEXCEPTION("MESH::getGroups : Unknown entity");
733 const MEDMEM::FAMILY* MESH::getFamily(medEntityMesh entity, int i) const
736 throw MEDEXCEPTION("MESH::getFamily(i) : argument i must be > 0");
737 vector<FAMILY*> Family;
740 Family = _familyNode;
744 Family = _familyCell;
748 Family = _familyFace;
752 Family = _familyEdge;
756 throw MEDEXCEPTION("MESH::getFamilies : Unknown entity");
759 throw MEDEXCEPTION("MESH::getFamily(entity,i) : argument i must be <= _numberOfFamilies");
763 const GROUP* MESH::getGroup(medEntityMesh entity, int i) const
765 const char * LOC = "MESH::getGroup(medEntityMesh entity, int i) : ";
767 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"argument i must be > 0"));
768 vector<GROUP*> Group;
787 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Unknown entity"));
790 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"argument i="<<i<<" must be <= _numberOfGroups="<<Group.size()));
799 //inline void MESH::write(const string & driverName) {
800 // write(0,driverName);
803 inline bool MESH::getIsAGrid()
810 #endif /* MESH_HXX */