src/MULTIPR/MULTIPR_Family.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_Family.hxx
   6  *
   7  * \brief   Class Family, Group and Attributs used to wrap MED file structures.
   8  *
   9  * \author  Olivier LE ROUX - CS, Virtual Reality Dpt
  10  *
  11  * \date    01/2007
  12  */
  13
  14 #ifndef MULTIPR_FAMILY_HXX
  15 #define MULTIPR_FAMILY_HXX
  16
  17 //*****************************************************************************
  18 // Includes section
  19 //*****************************************************************************
  20
  21 extern "C"
  22 {
  23         #include "med.h"
  24 }
  25
  26
  27 #include <iostream>
  28 #include <vector>
  29 #include <set>
  30 #include <map>
  31
  32
  33 namespace multipr
  34 {
  35
  36 //*****************************************************************************
  37 // Predeclaration
  38 //*****************************************************************************
  39
  40 class Group;
  41
  42
  43 //*****************************************************************************
  44 // Class Attributs
  45 //*****************************************************************************
  46
  47 class Attributs
  48 {
  49 public:
  50
  51         /**
  52          * Builds an empty Attributs (default constructor).
  53          */
  54         Attributs();
  55
  56         /**
  57          * Destructor. Removes everything.
  58          */
  59         ~Attributs();
  60
  61         /**
  62          * Assignment operator (deep copy).
  63          * \param  pAttr any Atttibuts to be copied.
  64          * \return a reference towards the copy.
  65          */
  66         Attributs& operator=(const Attributs& pAttr);
  67
  68         /**
  69          * Resets this object in its state by default (empty). Cleans memory.
  70          */
  71         void reset();
  72
  73         //---------------------------------------------------------------------
  74         // I/O
  75         //---------------------------------------------------------------------
  76
  77         /**
  78          * Dumps any Attributs to the given output stream.
  79          * \param  pOs any output stream.
  80          * \param  pA  any Attributs.
  81          * \return the output stream pOs.
  82          */
  83         friend std::ostream& operator<<(std::ostream& pOs, Attributs& pA);
  84
  85 public:
  86
  87         med_int   mNum;     /**< Number of attributes. */
  88         med_int*  mId;      /**< Table of identifiers: for each attribute, its identifier. */
  89         med_int*  mVal;     /**< Table of values; for each attribute, its value. */
  90         char*     mDesc;    /**< Table of description; for each attribute, its description. */
  91
  92 private:
  93
  94         // do not allow copy constructor
  95         Attributs(const Attributs&);
  96
  97         // do not allow operator ==
  98         bool operator==(const Attributs&);
  99
 100 }; // class Attribut
 101
 102
 103 //*****************************************************************************
 104 // Class Family
 105 //*****************************************************************************
 106
 107 class Family
 108 {
 109 public:
 110
 111         /**
 112          * Builds an empty Family (default constructor).
 113          */
 114         Family();
 115
 116         /**
 117          * Destructor. Removes everything.
 118          */
 119         ~Family();
 120
 121         /**
 122          * Resets this object in its state by default (empty). Cleans memory.
 123          */
 124         void reset();
 125
 126         //---------------------------------------------------------------------
 127         // Basic accessors/mutators
 128         //---------------------------------------------------------------------
 129
 130         /**
 131          * Returns the identifier (= number) of this Family.
 132          * \return the identifier of this Family.
 133          */
 134         med_int getId() const { return mId; }
 135
 136         /**
 137          * Returns the name of this Family.
 138          * \return the name of this Family.
 139          */
 140         const char* getName() const { return mName; }
 141
 142         /**
 143          * Returns true if this Family if a family of nodes, false if is a family of elements (=cells)).
 144          * \return true iff this Family if a family of nodes.
 145          */
 146         bool isFamilyOfNodes() const { return mIsFamilyOfNodes; }
 147
 148         /**
 149          * Sets whether this Family is a family of nodes or family of elements (= cells).
 150          * \param  pIsFamilyOfNodes flag.
 151          */
 152         void setIsFamilyOfNodes(bool pIsFamilyOfNodes) { mIsFamilyOfNodes = pIsFamilyOfNodes; }
 153
 154         /**
 155          * Inserts a new element (by its index) into this Family.
 156          * \param  pIndexElt index of the element to be added; must be >= 1.
 157          * \throw  IllegalArgumentException if pIndexElt <= 0.
 158          */
 159         void insertElt(med_int pIndexElt);
 160
 161         /**
 162          * Returns the number of elements in this Family.
 163          * \return the number of elements in this Family.
 164          */
 165         int getSize() const { return mElt.size(); }
 166
 167         //---------------------------------------------------------------------
 168         // Algorithms
 169         //---------------------------------------------------------------------
 170
 171         /**
 172          * Adds all the groups of this Family into the set of groups described by (pGroups, pGroupNameToGroup).
 173          * \param  pGroups            current list of groups.
 174          * \param  pGroupNameToGroup  table (map) to retrieve a Group* from its name.
 175          */
 176         void buildGroups(
 177                 std::vector<Group*>&            pGroups,
 178                 std::map<std::string, Group*>&  pGroupNameToGroup) const;
 179
 180         /**
 181          * Constructor. Returns a copy of this family restricted to the given group if pGroupName != NULL.
 182          * Examples:
 183          * 1. If current family have 3 groups "A", "B" and "C" and pGroupName="B", then the new family will only reference the group "B"
 184          * 2. If current family have 3 groups "A", "B" and "C" and pGroupName="D", then the new family will reference groups "A", "B" and "C".
 185          * WARNING: elements are not copied
 186          * \param   pGroupName name of the group to keep.
 187          * \return  a copy of this family.
 188          */
 189         Family* extractGroup(const char* pGroupName);
 190
 191         //---------------------------------------------------------------------
 192         // I/O
 193         //---------------------------------------------------------------------
 194
 195         /**
 196          * Reads a Family from a MED file.
 197          * \param  pMEDfile  any valid MED file opened for reading.
 198          * \param  pMeshName name of the mesh.
 199          * \param  pIndex    index of the family to be read (must be >= 1).
 200          * \throw  IOException if any i/o error occurs.
 201          */
 202         void readMED(med_idt pMEDfile, char* pMeshName, med_int pIndex);
 203
 204         /**
 205          * Writes this Family to a MED file.
 206          * WARNING: mesh must have been created and added to the MED file before.
 207          * \param  pMEDfile  any valid MED file opened for writing.
 208          * \param  pPeshName name of the mesh.
 209          * \throw  IOException if any i/o error occurs.
 210          */
 211         void writeMED(med_idt pMEDfile, char* pMeshName);
 212
 213         /**
 214          * Sets the flag which control the stream operator <<.
 215          * \param  pFlag new flag value.
 216          */
 217         void setPrintAll(bool pFlag) { mFlagPrintAll = pFlag; }
 218
 219         /**
 220          * Dumps any Family to the given output stream.
 221          * \param  pOs any output stream.
 222          * \param  pF  any Family.
 223          * \return the output stream pOs.
 224          */
 225         friend std::ostream& operator<<(std::ostream& pOs, Family& pF);
 226
 227 private:
 228
 229         char                     mName[MED_TAILLE_NOM + 1];   /** Name of the Family */
 230         med_int                  mId;               /**< Id: > 0 if family of nodes; < 0 if family of elements. */
 231         std::set<med_int>        mElt;              /**< Set of all the elements (by their index in 1..*). */
 232         std::string              mStrNameGroups;    /**< A string with name of all groups which contain the Family. */
 233         std::vector<std::string> mNameGroups;       /**< List of groups (by name) which contain the Family. */
 234         Attributs                mAttributs;        /**< All the attributed related to the Family. */
 235         bool                     mIsFamilyOfNodes;  /**< Is it a family of nodes or a family of elements? */
 236
 237         bool                     mFlagPrintAll;     /** Flag to control the behaviour of the stream operator <<. */
 238
 239 private:
 240
 241         // do not allow copy constructor
 242         Family(const Family&);
 243
 244         // do not allow copy
 245         Family& operator=(const Family&);
 246
 247         // do not allow operator ==
 248         bool operator==(const Family&);
 249
 250 }; // class Family
 251
 252
 253 //*****************************************************************************
 254 // Class Group
 255 //*****************************************************************************
 256
 257 class Group
 258 {
 259 public:
 260
 261         /**
 262          * Builds an empty group (default constructor).
 263          */
 264         Group();
 265
 266         /**
 267          * Destructor. Removes everything.
 268          */
 269         ~Group();
 270
 271         /**
 272          * Resets this object in its state by default (empty). Cleans memory.
 273          */
 274         void reset();
 275
 276         //---------------------------------------------------------------------
 277         // Basic accessors/mutators
 278         //---------------------------------------------------------------------
 279
 280         /**
 281          * Returns true if it is a group of nodes, false if it is a group of elements.
 282          * \return true if it is a group of nodes, false if it is a group of elements.
 283          */
 284         bool isGroupOfNodes() const { return mIsGroupOfNodes; }
 285
 286         /**
 287          * Sets whether it is a group of nodes or a group of elements.
 288          * \param  pIsGroupOfNodes true for a group of nodes, false for a group of elements.
 289          */
 290         void setIsGroupOfNodes(bool pIsGroupOfNodes) { mIsGroupOfNodes = pIsGroupOfNodes; }
 291
 292         /**
 293          * Returns the name of this Group.
 294          * \return the name of this Group.
 295          */
 296         const std::string& getName() const { return mName; }
 297
 298         /**
 299          * Sets the name of this Group.
 300          * \param  pName new name of this Group (length of name must not exceed MED_TAILLE_LNOM).
 301          */
 302         void setName(const std::string& pName);
 303
 304         /**
 305          * Adds the index of a new element to this Group.
 306          * \param  pIndexElt must be >= 1.
 307          */
 308         void insertElt(med_int pIndexElt);
 309
 310         /**
 311          * Returns the set of all the elements referenced in this Group.
 312          * \return the set of all the elements referenced in this Group.
 313          */
 314         const std::set<med_int>& getSetOfElt() const { return mElt; }
 315
 316         /**
 317          * Returns the number of elements referenced in this Group.
 318          * \return the number of elements referenced in this Group.
 319          */
 320         int getSize() const { return mElt.size(); }
 321
 322         //---------------------------------------------------------------------
 323         // I/O
 324         //---------------------------------------------------------------------
 325
 326         /**
 327          * Sets the flag which control the stream operator <<.
 328          * \param  pFlag new flag value.
 329          */
 330         void setPrintAll(bool pFlag) { mFlagPrintAll = pFlag; }
 331
 332         /**
 333          * Dumps any Group to the given output stream.
 334          * \param  pOs any output stream.
 335          * \param  pG  any Group.
 336          * \return the output stream pOs.
 337          */
 338         friend std::ostream& operator<<(std::ostream& pOs, Group& pG);
 339
 340 private:
 341
 342         std::string        mName;            /**< Name of the group. */
 343         std::set<med_int>  mElt;             /**< All elements of this group; each element is referenced by its index >= 1; each element is unique. */
 344         bool               mIsGroupOfNodes;  /**< Is it a group of nodes or a group of elements? */
 345
 346         bool               mFlagPrintAll;    /** Flag to control the behaviour of the stream operator <<. */
 347
 348 private:
 349
 350         // do not allow copy constructor
 351         Group(const Group&);
 352
 353         // do not allow copy
 354         Group& operator=(const Group&);
 355
 356         // do not allow operator ==
 357         bool operator==(const Group&);
 358
 359 }; // class Group
 360
 361
 362 } // namespace MULTIPR
 363
 364
 365 #endif // MULTIPR_FAMILY_HXX
 366
 367 // EOF