src/MULTIPR/MULTIPR_Mesh.hxx

   1 // Project MULTIPR, IOLS WP1.2.1 - EDF/CS
   2 // Partitioning/decimation module for the SALOME v3.2 platform
   3
   4 /**
   5  * \file    MULTIPR_Mesh.hxx
   6  *
   7  * \brief   Class Mesh used by the MULTIPR API; used to wrap MED file meshes.
   8  *
   9  * \author  Olivier LE ROUX - CS, Virtual Reality Dpt
  10  *
  11  * \date    01/2007
  12  */
  13
  14 #ifndef MULTIPR_MESH_HXX
  15 #define MULTIPR_MESH_HXX
  16
  17 //*****************************************************************************
  18 // Includes section
  19 //*****************************************************************************
  20
  21 extern "C"
  22 {
  23     #include "med.h"
  24 }
  25
  26 #include <iostream>
  27 #include <fstream>
  28 #include <set>
  29 #include <map>
  30 #include <vector>
  31 #include <string>
  32
  33
  34 namespace multipr
  35 {
  36
  37 //*****************************************************************************
  38 // Pre-declaration
  39 //*****************************************************************************
  40
  41 class GaussLoc;
  42 class Profil;
  43 class Nodes;
  44 class Elements;
  45 class Family;
  46 class Field;
  47 class Group;
  48 class MeshDis;
  49 class PointOfField;
  50
  51
  52 //*****************************************************************************
  53 // Class Mesh
  54 //*****************************************************************************
  55
  56 /**
  57  * Assumes:
  58  * - 3D mesh in a 3D space
  59  * - Unstructured mesh (not a grid)
  60  * - Nodal connectivity
  61  * - Cartesian coordinates system
  62  * Always use FULL_INTERLACE arrays
  63  */
  64 class Mesh
  65 {
  66 public:
  67
  68     /**
  69      * Builds an empty Mesh (default constructor).
  70      */
  71     Mesh();
  72
  73     /**
  74      * Destructor. Removes everything.
  75      */
  76     ~Mesh();
  77
  78     /**
  79      * Resets this object in its state by default (empty). Cleans memory.
  80      */
  81     void reset();
  82
  83     //---------------------------------------------------------------------
  84     // Basic accessors/mutators
  85     //---------------------------------------------------------------------
  86
  87     /**
  88      * Returns the name of this Mesh.
  89      * \return the name of this Mesh.
  90      */
  91     const char* getName() const { return mMeshName; }
  92
  93     /**
  94      * Returns the name of all the scalar fields.
  95      * \return the name of all the scalar fields.
  96      */
  97     std::vector<std::string> getNameScalarFields() const;
  98
  99     /**
 100      * Returns the number of iteration for a given field.
 101      * \return the number of iteration for a given field.
 102      */
 103     int getTimeStamps(const char* pFieldName) const;
 104
 105     /**
 106      * Returns a Field from its name; NULL if it does not exist.
 107      * \param  pFieldName name of the field to be retrieved.
 108      * \return the Field pFieldName of it exists, NULL otherwise.
 109      * \throw  NullArgumentException if pFieldName is NULL.
 110      */
 111     Field* getFieldByName(const char* pFieldName) const;
 112
 113     /**
 114      * Returns a GaussLoc from its name; NULL if it does not exist.
 115      * \param  pGaussLocName name of the GaussLoc to be retrieved.
 116      * \return the GaussLoc pGaussLocName if it exists, NULL otherwise.
 117      * \throw  NullArgumentException if pGaussLocName is NULL.
 118      */
 119     GaussLoc* getGaussLocByName(const char* pGaussLocName) const;
 120
 121     /**
 122      * Returns the number of elements.
 123      * \return the number of elements.
 124      */
 125     int getNumberOfElements() const;
 126
 127     //---------------------------------------------------------------------
 128     // Algorithms
 129     //---------------------------------------------------------------------
 130
 131     /**
 132      * Creates a Mesh from a subset of its elements (cells).
 133      * \param  pSetOfElements subset of elements to keep.
 134      * \param  pNewMeshName   name of the new Mesh.
 135      * \return a new Mesh which is a restriction of this Mesh to the given set of elements.
 136      * \throw  NullArgumentException if pNewMeshName is NULL.
 137      */
 138     Mesh* createFromSetOfElements(const std::set<med_int>& pSetOfElements, const char* pNewMeshName);
 139
 140     /**
 141      * Creates a Mesh from one of its group.
 142      * \param  pGroup       any group of this Mesh.
 143      * \param  pNewMeshName name of the new Mesh.
 144      * \return a new Mesh which is a restriction of this Mesh to pGroup.
 145      * \throw  NullArgumentException if pGroup or pNewMeshName is NULL.
 146      */
 147     Mesh* createFromGroup(const Group* pGroup, const char* pNewMeshName);
 148
 149     /**
 150      * Creates a distributed mesh (MeshDis) by creating a new mesh for each group of elements in this Mesh.
 151      * \return a distributed mesh from groups of this Mesh.
 152      */
 153     MeshDis* splitGroupsOfElements();
 154
 155     /**
 156      * Creates a new mesh by decimating this one.
 157      * \param  pFilterName  name of the filter to be used for decimation (e.g. Filtre_GradientMoyen); should not be NULL.
 158      * \param  pArgv        all the arguments for filtering as a single string.
 159      * \param  pNameNewMesh name of the new mesh.
 160      * \return the decimated mesh.
 161      * \throw  NullArgumentException if one of the arguments is NULL.
 162      * \throw  RuntimeException if any error occurs while decimating data.
 163      */
 164     Mesh* decimate(
 165         const char* pFilterName,
 166         const char* pArgv,
 167         const char* pNameNewMesh);
 168
 169     /**
 170      * Gets all the points in a field. Each point has coordinates and a value.
 171      * \param  pField      any field of this Mesh.
 172      * \param  pTimeStepIt time step iteration.
 173      * \param  pPoints     (out) list of points.
 174      * \throw  NullArgumentException if pField is NULL.
 175      * \throw  IllegalArgumentException if pTimeStepIt is invalid.
 176      */
 177     void getAllPointsOfField(Field* pField, int pTimeStepIt, std::vector<PointOfField>& pPoints);
 178
 179     /**
 180      * Returns a default value for neighborhood radius.
 181      * Return value is such that, for any point in the field, average number of neighbours is pN.
 182      * \param  pN average number of neighbours.
 183      * \return a default value for neighborhood radius; 1.0 if some error occurs.
 184      */
 185     float evalDefaultRadius(int pN) const;
 186
 187     //---------------------------------------------------------------------
 188     // I/O
 189     //---------------------------------------------------------------------
 190
 191     /**
 192      * Reads a Mesh from a sequential MED file. Resets the object before.
 193      * \param  pMEDfilename
 194      * \param  pMeshName
 195      * \throw  IOException if any i/o error occurs.
 196      */
 197     void readSequentialMED(const char* pMEDfilename, const char* pMeshName);
 198
 199     /**
 200      * Writes this Mesh and all related things into a MED file.
 201      * \param  pMEDfilename
 202      * \throw  IOException if any i/o error occurs.
 203      */
 204     void writeMED(const char* pMEDfilename);
 205
 206     /**
 207      * Sets the flag which control the stream operator <<.
 208      * \param pFlag new flag value.
 209      */
 210     void setPrintAll(bool pFlag) { mFlagPrintAll = pFlag; }
 211
 212     /**
 213      * Dumps any Mesh to the given output stream.
 214      * \param  pOs any output stream.
 215      * \param  pM  any Mesh.
 216      * \return the output stream pOs.
 217      */
 218     friend std::ostream& operator<<(std::ostream& pOs, Mesh& pM);
 219
 220 private:
 221
 222     /**
 223      * Reads all Gauss localizations in the current MED file.
 224      * \throw  IOException if an i/o error occurs.
 225      */
 226     void readGaussLoc();
 227
 228     /**
 229      * Reads families in the currentMED file and build groups.
 230      * \throw  IOException if an i/o error occurs.
 231      */
 232     void readFamilies();
 233
 234     /**
 235      * Finalizes the constructions of families and groups.
 236      * Fill structures with elements.
 237      */
 238     void finalizeFamiliesAndGroups();
 239
 240     /**
 241      * Reads fields related to this mesh in the current MED file.
 242      * \throw  IOException if an i/o error occurs.
 243      */
 244     void readFields();
 245
 246 private:
 247
 248     /**
 249      * Name of the associated MED file.
 250      */
 251     char                              mMEDfilename[256];
 252
 253     /**
 254      * MED file handle.
 255      */
 256     med_idt                           mMEDfile;
 257
 258     /**
 259      * Name of this mesh.
 260      */
 261     char                              mMeshName[MED_TAILLE_NOM + 1];
 262
 263     /**
 264      * Universal name of this mesh.
 265      */
 266     char                              mMeshUName[MED_TAILLE_DESC + 1];
 267
 268     /**
 269      * Description.
 270      */
 271     char                              mMeshDesc[MED_TAILLE_DESC + 1];
 272
 273     /**
 274      * Dimension.
 275      */
 276     med_int                           mMeshDim;
 277
 278     /**
 279      * Type of mesh (MED_NON_STRUCTURE or MED_STRUCTURE (=grid))
 280      */
 281     med_maillage                      mMeshType;
 282
 283     /**
 284      * Axis aligned bounding box of this mesh.
 285      */
 286     med_float                         mMeshBBoxMin[3];
 287     med_float                         mMeshBBoxMax[3];
 288
 289     /**
 290      * All the nodes used by this mesh.
 291      */
 292     Nodes*                            mNodes;
 293
 294     /**
 295      * All the TETRA10 elements used by this mesh.
 296      */
 297     Elements*                         mElements;
 298
 299     /**
 300      * Table of families used by this mesh.
 301      */
 302     std::vector<Family*>              mFamilies;
 303
 304     /**
 305      * Map to retrieve a Family from its name.
 306      */
 307     std::map<med_int, Family*>        mFamIdToFam;
 308
 309     /**
 310      * Table of groups used by this mesh.
 311      */
 312     std::vector<Group*>               mGroups;
 313
 314     /**
 315      * Map to retrieve a Group from its name.
 316      */
 317     std::map<std::string, Group*>     mGroupNameToGroup;
 318
 319     /**
 320      * Table of GaussLoc.
 321      */
 322     std::vector<GaussLoc*>            mGaussLoc;
 323
 324     /**
 325      * Map to retrieve a Gauss info from its name.
 326      */
 327     std::map<std::string, GaussLoc*>  mGaussLocNameToGaussLoc;
 328
 329     /**
 330      * Table of fields related to this mesh.
 331      * Number of fiels = mFields.size().
 332      */
 333     std::vector<Field*>               mFields;
 334
 335     /**
 336      * Table of profils.
 337      */
 338     std::vector<Profil*>              mProfils;
 339
 340     /**
 341      * Flag to control the behaviour of the stream operator <<.
 342      */
 343     bool                              mFlagPrintAll;
 344
 345 private:
 346
 347     // do not allow copy constructor
 348     Mesh(const Mesh&);
 349
 350     // do not allow copy
 351     Mesh& operator=(const Mesh&);
 352
 353     // do not allow operator ==
 354     bool operator==(const Mesh&);
 355
 356 }; // class Mesh
 357
 358
 359 } // namespace MULTIPR
 360
 361
 362 #endif // MULTIPR_MESH_HXX
 363
 364 // EOF