src/MEDMEM/MEDMEM_Meshing.cxx

   1 // Copyright (C) 2005  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   2 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   3 //
   4 // This library is free software; you can redistribute it and/or
   5 // modify it under the terms of the GNU Lesser General Public
   6 // License as published by the Free Software Foundation; either
   7 // version 2.1 of the License.
   8 //
   9 // This library is distributed in the hope that it will be useful
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 // Lesser General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Lesser General Public
  15 // License along with this library; if not, write to the Free Software
  16 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 //
  18 // See http://www.salome-platform.org/
  19 //
  20 /*
  21   File MEDMEM_Meshing.cxx
  22   $Header$
  23 */
  24
  25 #include <string>
  26
  27 #include "MEDMEM_Utilities.hxx"
  28 #include "MEDMEM_STRING.hxx"
  29 #include "MEDMEM_Exception.hxx"
  30 #include "MEDMEM_define.hxx"
  31
  32 #include "MEDMEM_Meshing.hxx"
  33 #include "MEDMEM_Group.hxx"
  34
  35 using namespace std;
  36 using namespace MEDMEM;
  37 using namespace MED_EN;
  38
  39 /*! Create an empty MESH. */
  40 MESHING::MESHING(): MESH()
  41 {
  42   MESSAGE("MESHING::MESHING()");
  43   SCRUTE(_coordinate);
  44   SCRUTE(_connectivity);
  45 }
  46
  47 MESHING::~MESHING()
  48 {
  49   MESSAGE("Deletinh MESHING !!");
  50 }
  51
  52 /*! Set the dimension of the space */
  53 void MESHING::setSpaceDimension(const int SpaceDimension)
  54 {
  55   _spaceDimension = SpaceDimension ;
  56 }
  57
  58 /*! Set the dimension of the MESHING */
  59 void MESHING::setMeshDimension(const int MeshDimension)
  60 {
  61    _meshDimension = MeshDimension ;
  62    _connectivity->setEntityDimension(MeshDimension);
  63 }
  64
  65 /*! Set the number of nodes used in the MESH */
  66 void MESHING::setNumberOfNodes(const int NumberOfNodes)
  67 {
  68   _numberOfNodes = NumberOfNodes ;
  69 }
  70
  71 /*!
  72   Set the whole coordinates array in a given system and interlacing mode.
  73   The system coordinates are :
  74     - "CARTESIAN"
  75     - "CYLINDRICAL"
  76     - "SPHERICAL"
  77   The interlacing mode are :
  78     - MED_NO_INTERLACE   :  X1 X2 Y1 Y2 Z1 Z2
  79     - MED_FULL_INTERLACE :  X1 Y1 Z1 X2 Y2 Z2
  80 */
  81 void MESHING::setCoordinates(const int SpaceDimension,
  82                              const int NumberOfNodes,
  83                              const double * Coordinates,
  84                              const string System,
  85                              const medModeSwitch Mode)
  86 {
  87   setSpaceDimension(SpaceDimension);
  88   setNumberOfNodes(NumberOfNodes);
  89
  90   SCRUTE(_coordinate);
  91   SCRUTE(_connectivity);
  92   //if (NULL != _coordinate) delete _coordinate;
  93
  94   _coordinate = new COORDINATE(SpaceDimension,
  95                                NumberOfNodes,
  96                                Mode);
  97   _coordinate->setCoordinates(Mode,Coordinates);
  98   _coordinate->setCoordinatesSystem(System);
  99 }
 100
 101 /*! Set the system in which coordinates are given (CARTESIAN,CYLINDRICAL,SPHERICAL) __??MED_CART??__. */
 102 void MESHING::setCoordinatesSystem(const string System)
 103   throw (MEDEXCEPTION)
 104 {
 105   if (NULL == _coordinate)
 106     throw MEDEXCEPTION(LOCALIZED("MESHING::setCoordinatesSystem : no coordinates defined"));
 107   _coordinate->setCoordinatesSystem(System);
 108 }
 109
 110 /*! Set the coordinate names array ("x       ","y       ","z       ")
 111   of size n*MED_TAILLE_PNOM
 112 */
 113 void MESHING::setCoordinatesNames(const string * name)
 114 {
 115 //    int SpaceDimension = getSpaceDimension() ;
 116 //    _coordinate->setCoordinatesNames(SpaceDimension,name);
 117   _coordinate->setCoordinatesNames(name);
 118 }
 119
 120 /*!
 121   Set the (i+1)^th component of coordinate names array
 122   ("x       ","y       ","z       ") of size n*MED_TAILLE_PNOM
 123 */
 124 void MESHING::setCoordinateName(const string name, const int i)
 125 {
 126   _coordinate->setCoordinateName(name,i);
 127 }
 128
 129 /*! Set the coordinate unit names array ("cm       ","cm       ","cm       ")
 130   of size n*MED_TAILLE_PNOM
 131 */
 132 void MESHING::setCoordinatesUnits(const string * units)
 133 {
 134 //    int SpaceDimension = getSpaceDimension() ;
 135 //    _coordinate->setCoordinatesUnits(SpaceDimension,units);
 136   _coordinate->setCoordinatesUnits(units);
 137 }
 138
 139 /*!
 140   Set the (i+1)^th component of the coordinate unit names array
 141   ("cm       ","cm       ","cm       ") of size n*MED_TAILLE_PNOM
 142 */
 143 void MESHING::setCoordinateUnit(const string unit, const int i)
 144 {
 145   _coordinate->setCoordinateUnit(unit,i);
 146 }
 147
 148 /*!
 149   Create a new connectivity object with the given number of type and
 150   entity. If a connectivity already exist, delete it !
 151
 152   For exemple setNumberOfTypes(3,MED_CELL) create a connectivity with 3
 153   medGeometryElement in MESH for MED_CELL entity (like MED_TETRA4,
 154   MED_PYRA5 and MED_HEXA6 for example).
 155
 156   Return an exception if could not create the connectivity (as if we set
 157   MED_FACE connectivity before MED_CELL).
 158 */
 159 void MESHING::setNumberOfTypes(const int NumberOfTypes,
 160                                const medEntityMesh Entity)
 161   throw (MEDEXCEPTION)
 162 {
 163   const char * LOC = "MESHING::setNumberOfTypes( medEntityMesh ) : ";
 164
 165   // No defined for MED_NODE !
 166   if (Entity == MED_NODE)
 167     throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Not required with MED_NODE !"));
 168
 169   if (MED_CELL == Entity) {
 170     SCRUTE(_connectivity);
 171 //     if (_connectivity != (CONNECTIVITY *) NULL)
 172 //       delete _connectivity ;
 173     _connectivity = new CONNECTIVITY(NumberOfTypes,Entity) ;
 174
 175   } else {
 176
 177     if (_connectivity == NULL) // we must have defined MED_CELL connectivity
 178       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"No connectivity on MED_CELL defined !"));
 179
 180     if (MED_FACE == Entity)
 181       if (3 != getSpaceDimension())
 182         throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"No connectivity on MED_FACE could be defined in non 3D space !"));
 183
 184     if (MED_EDGE == Entity)
 185       if (3 == getSpaceDimension()) {
 186         if (!_connectivity->existConnectivity(MED_NODAL,MED_FACE))
 187           throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"No connectivity on MED_FACE defined !"));
 188       } else {
 189         if (2 != getSpaceDimension())
 190           throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Could not set connectivity on MED_EDGE !"));
 191       }
 192     // all rigth, we could create connectivity !
 193     CONNECTIVITY * myConnectivity = new CONNECTIVITY(NumberOfTypes,Entity) ;
 194     _connectivity->setConstituent(myConnectivity);
 195   }
 196 }
 197
 198 /*!
 199   Set the list of geometric types used by a given entity.
 200   medEntityMesh entity could be : MED_CELL, MED_FACE, MED_EDGE
 201
 202   REM : Don't use MED_NODE and MED_ALL_ENTITIES
 203
 204   If entity is not defined, throw an exception.
 205 */
 206 void MESHING::setTypes(const medGeometryElement * Types,
 207                        const medEntityMesh entity)
 208   throw (MEDEXCEPTION)
 209 {
 210   if (entity == MED_NODE)
 211     throw MEDEXCEPTION(LOCALIZED("MESHING::setTypes : Not defined with MED_NODE entity !"));
 212
 213   if (_connectivity == NULL)
 214     throw MEDEXCEPTION(LOCALIZED("MESHING::setTypes : No connectivity defined !"));
 215
 216   _connectivity->setGeometricTypes(Types,entity) ;
 217 }
 218
 219 /*!
 220   Set the number of elements for each geometric type of given entity.
 221
 222   Example : setNumberOfElements({12,23},MED_FACE)
 223   if we have two type of face (MED_TRIA3 and MED_QUAD4),
 224   we set 12 triangles and 23 quadrangles.
 225 */
 226 void MESHING::setNumberOfElements(const int * NumberOfElements,
 227                                   const medEntityMesh Entity)
 228   throw (MEDEXCEPTION)
 229 {
 230   const char * LOC = "MESHING::setNumberOfElements(const int *, medEntityMesh) : " ;
 231
 232   if (Entity==MED_NODE)
 233     throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Not defined with MED_NODE entity !"));
 234
 235   if (_connectivity == (CONNECTIVITY*)NULL)
 236     throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"No connectivity defined !"));
 237
 238   int NumberOfTypes = getNumberOfTypes(Entity) ;
 239   int * Count = new int[NumberOfTypes+1] ;
 240   Count[0]=1 ;
 241   for (int i=0; i<NumberOfTypes; i++)
 242     Count[i+1]=Count[i]+NumberOfElements[i] ;
 243   _connectivity->setCount(Count,Entity) ;
 244   delete[] Count ;
 245 }
 246
 247 /*!
 248   Set the nodal connectivity for one geometric type of the given entity.
 249
 250   Example : setConnectivity({1,2,3,1,4,2},MED_FACE,MED_TRIA3)
 251   Define 2 triangles face defined with nodes 1,2,3 and 1,4,2.
 252 */
 253 void MESHING::setConnectivity(const int * Connectivity,
 254                               const medEntityMesh Entity,
 255                               const medGeometryElement Type)
 256   throw (MEDEXCEPTION)
 257 {
 258   const char * LOC = "MESHING::setConnectivity : " ;
 259
 260   if (Entity==MED_NODE)
 261     throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Not defined with MED_NODE entity !"));
 262
 263   if (_connectivity == (CONNECTIVITY*)NULL)
 264     throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"No connectivity defined !"));
 265
 266   _connectivity->setNodal(Connectivity,Entity,Type) ;
 267 }
 268
 269 void MESHING::setPolygonsConnectivity     (const int * ConnectivityIndex,
 270                                            const int * ConnectivityValue,
 271                                            int nbOfPolygons,
 272                                            const MED_EN::medEntityMesh Entity)
 273   throw (MEDEXCEPTION)
 274 {
 275   if (_connectivity == (CONNECTIVITY*)NULL)
 276     throw MEDEXCEPTION("No connectivity defined !");
 277   if(_connectivity->getPolyTypeRelativeTo()==MED_EN::MED_POLYGON)
 278     {
 279       _connectivity->setPolygonsConnectivity(MED_NODAL, Entity, ConnectivityValue, ConnectivityIndex,ConnectivityIndex[nbOfPolygons]-1,nbOfPolygons) ;
 280     }
 281   else
 282     throw MEDEXCEPTION("Invalid connectivity for polygons !!!");
 283 }
 284
 285 void MESHING::setPolyhedraConnectivity     (const int * PolyhedronIndex,
 286                                             const int * FacesIndex,
 287                                             const int * Nodes,
 288                                             int nbOfPolyhedra,
 289                                             const MED_EN::medEntityMesh Entity)
 290   throw (MEDEXCEPTION)
 291 {
 292   if (_connectivity == (CONNECTIVITY*)NULL)
 293     throw MEDEXCEPTION("No connectivity defined !");
 294   if(_connectivity->getPolyTypeRelativeTo()==MED_EN::MED_POLYHEDRA)
 295     {
 296       int nbOfFacesOfAllPolyhedra=PolyhedronIndex[nbOfPolyhedra]-1;
 297       _connectivity->setPolyhedronConnectivity(MED_NODAL, Nodes, PolyhedronIndex, FacesIndex[nbOfFacesOfAllPolyhedra]-1 , nbOfPolyhedra, FacesIndex, nbOfFacesOfAllPolyhedra) ;
 298     }
 299   else
 300     throw MEDEXCEPTION("Invalid connectivity for polyhedra !!!");
 301 }
 302
 303 /*!
 304   NOT YET IMPLEMENTED !! WARNING
 305 */
 306 void MESHING::setConnectivities (const int * ConnectivityIndex,
 307                                  const int * ConnectivityValue,
 308                                  const medConnectivity ConnectivityType,
 309                                  const medEntityMesh Entity)
 310   throw (MEDEXCEPTION)
 311 {
 312   const char * LOC = "MESHING::setConnectivities : " ;
 313   SCRUTE(Entity);
 314   SCRUTE(ConnectivityType);
 315   SCRUTE(ConnectivityValue);
 316   SCRUTE(ConnectivityIndex);
 317
 318   throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Not Yet Implemented :: Warning !"));
 319 }
 320
 321 /*!
 322 */
 323
 324 // void MESHING::setGroup(const string name,
 325 //                     const string description,
 326 //                     const int NumberOfElements,
 327 //                     const int * ElementsNumbers,
 328 //                     const medEntityMesh Entity)
 329 // {
 330 //   GROUP * myGroup = new GROUP() ;
 331 //   myGroup->setMesh(*this) ;
 332 //   myGroup->setName(name) ;
 333 //   myGroup->setDescription(description) ;
 334 //   myGroup->setEntity(Entity) ;
 335 //   // medEntityMesh and medGeometryElement ???
 336 //   myGroup->setNumberOfGeometricType(NumberOfType) ;
 337 //   myGroup->setGeometricType(Type) ;
 338 //   myGroup->setNumberOfGaussPoint(NumberOfGaussPoint) ;
 339 //   myGroup->setNumberOfElements(NumberOfElements) ;
 340 //   myGroup->setNumber(Number) ;
 341 // }
 342
 343 void MESHING::addGroup(const GROUP & Group)
 344   throw (MEDEXCEPTION)
 345 {
 346   const char * LOC = "MESHING::addGroup : " ;
 347
 348   GROUP * myGroup = new GROUP(Group) ;
 349   switch(Group.getEntity()){
 350   case MED_CELL : {
 351     _groupCell.push_back(myGroup);
 352     break;
 353   }
 354   case MED_FACE : {
 355      _groupFace.push_back(myGroup);
 356     break;
 357   }
 358   case MED_EDGE : {
 359      _groupEdge.push_back(myGroup);
 360     break;
 361   }
 362   case MED_NODE : {
 363      _groupNode.push_back(myGroup);
 364     break;
 365   }
 366   default :
 367     throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Bad Entity !"));
 368   }
 369 }