src/MULTIPR/MULTIPR_Obj.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_GaussLoc.hxx
   6  *
   7  * \brief   Class MULTIPR_Obj.
   8  *          This class is used as an interface to implement MULTIPR services in the salome MODULE
   9  *          as described in the spec/design doc.
  10  *
  11  * \author  Olivier LE ROUX - CS, Virtual Reality Dpt
  12  *
  13  * \date    01/2007
  14  */
  15
  16 #ifndef MULTIPR_OBJ_HXX
  17 #define MULTIPR_OBJ_HXX
  18
  19 //*****************************************************************************
  20 // Includes section
  21 //*****************************************************************************
  22
  23 #include <iostream>
  24 #include <string>
  25 #include <vector>
  26
  27
  28 namespace multipr
  29 {
  30
  31 class MeshDis;
  32
  33
  34 //*****************************************************************************
  35 // Class Obj
  36 //*****************************************************************************
  37
  38 enum ObjState
  39 {
  40     MULTIPR_OBJ_STATE_ERROR,
  41     MULTIPR_OBJ_STATE_RESET,
  42     MULTIPR_OBJ_STATE_SEQ_INIT,
  43     MULTIPR_OBJ_STATE_SEQ,
  44     MULTIPR_OBJ_STATE_DIS,
  45     MULTIPR_OBJ_STATE_DIS_MEM
  46 }; // enum ObjState
  47
  48
  49 class Obj
  50 {
  51 public:
  52
  53     /**
  54      * Builds an empty Gauss reference (default constructor).
  55      */
  56     Obj();
  57
  58     /**
  59      * Destructor. Removes everything.
  60      */
  61     ~Obj();
  62
  63     /**
  64      * Resets this object in its state by default (empty). Cleans memory.
  65      */
  66     void reset();
  67
  68     /**
  69      * Associate a MED file (sequential or distributed) with this object.
  70      * This method also:
  71      * - reset everything before starting
  72      * - determine if the given file is a sequential (SEQ) or a distributed (DIS) MED file
  73      * - read the ASCII master file if it is a distributed MED file
  74      * - set state
  75      */
  76     void create(const char* pMEDfilename);
  77
  78     //---------------------------------------------------------------------
  79     // Basic accessors/mutators
  80     //--------------------------------------------------------------------
  81
  82     /**
  83      * Returns true iff this obj represents a valid sequential MED file.
  84      * \return true iff this obj represents a valid sequential MED file.
  85      */
  86     bool isValidSequentialMEDFile() const { return (mState == MULTIPR_OBJ_STATE_SEQ) || (mState == MULTIPR_OBJ_STATE_SEQ_INIT); }
  87
  88     /**
  89      * Returns true iff this obj represents a valid distributed MED file.
  90      * \return true iff this obj represents a valid distributed  MED file.
  91      */
  92     bool isValidDistributedMEDFile() const { return (mState == MULTIPR_OBJ_STATE_DIS) || (mState == MULTIPR_OBJ_STATE_DIS_MEM); }
  93
  94     /**
  95      * Returns the name of the associated MED file.
  96      * \return the name of the associated MED file.
  97      */
  98     std::string getMEDFilename() const { return mMEDfilename; }
  99
 100     /**
 101      * Returns the name of the associated sequential MED file.
 102      * \return the name of the associated sequential MED file.
 103      */
 104     std::string getSequentialMEDFilename() const;
 105
 106     /**
 107      * Defines the mesh to be processed.
 108      * \param  pMeshName name of the mesh to be partitionned.
 109      */
 110     void setMesh(const char* pMeshName);
 111
 112     /**
 113      * Returns the list of meshes contained in the sequential MED file.
 114      * Assumes this object encapsulates a sequential MED file.
 115      * \return the list of meshes contained in the sequential MED file.
 116      */
 117     std::vector<std::string> getMeshes() const;
 118
 119     /**
 120      * Returns the list of fields contained in the sequential MED file.
 121      * Assumes this object encapsulates a sequential MED file.
 122      * \return the list of fields contained in the sequential MED file.
 123      */
 124     std::vector<std::string> getFields() const;
 125
 126     /**
 127      * Returns the number of timestamps for a given field.
 128      * Assumes this object encapsulates a sequential MED file.
 129      * \param  pFieldName name of any field.
 130      * \return the number of timestamps for a given field; 0 if field not found.
 131      */
 132     int getTimeStamps(const char* pFieldName) const;
 133
 134     /**
 135      * Returns the name of all partitions.
 136      * Assumes this object encapsulates a distributed MED file.
 137      * \return the name of all partitions.
 138      */
 139     std::vector<std::string> getParts() const;
 140
 141     /**
 142      * Returns all information about a part.
 143      * \param  pPartName name of the part.
 144      * \return all information about a part.
 145      */
 146     std::string getPartInfo(const char* pPartName) const;
 147
 148     /**
 149      * Removes all the part beginning by pPrefixPartName from the distributed MED file.
 150      * Example: if pPrefixPartName="PART_4" => remove "PART_4" and all sub-parts "PART_4_*", but not "PART41".
 151      * Assume this object encapsulates a distributed MED file.
 152      * \param  pPrefixPartName name of the part.
 153      */
 154     void removeParts(const char* pPrefixPartName);
 155
 156
 157     //---------------------------------------------------------------------
 158     // Algorithms
 159     //--------------------------------------------------------------------
 160
 161     /**
 162      * Creates a distributed MED file (v2.3) by extracting all the groups from the current mesh of the current MED sequential MED file.
 163      *         Assumes:
 164      *         - the file is in MED format and can be read using MED file v2.3.
 165      *         - the file is sequential (not a distributed MED).
 166      *         - the file only contains TETRA10 elements (dimension of space and mesh is 3).
 167      *         - the file have no profil.
 168      * \return the name of each part.
 169      * \throw  RuntimeException if any error occurs.
 170      */
 171     std::vector<std::string> partitionneDomaine();
 172
 173     /**
 174      * Creates a distributed MED file (V2.3) by splitting a group of a MED file previously created by partitionneDomaine.
 175      *         Assumes:
 176      *         - the file is a distributed MED file, previously created by partitionneDomaine()
 177      *           (=> each part only contain 1 mesh, TETRA10 elements only)
 178      *         - nbPart > 1
 179      * \param  pPartName     name of the part to be splitted.
 180      * \param  pNbParts      number of parts; must be > 1.
 181      * \param  pPartitionner use value 0=MULTIPR_METIS for Metis or 1=MULTIPR_SCOTCH for Scotch.
 182      * \return the name of each part.
 183      * \throw  RuntimeException if any error occurs.
 184      */
 185     std::vector<std::string> partitionneGrain(
 186         const char* pPartName,
 187         int         pNbParts,
 188         int         pPartitionner=0);
 189
 190     /**
 191      * Creates 3 resolutions of the given part of a distributed MED file (V2.3).
 192      *         Assumes:
 193      *         - the file is a distributed MED file, previously created by partitionneDomaine() or partitionneGrain()
 194      *           (=> each part only contain 1 mesh, TETRA10 elements only)
 195      * \param  pPartName    name of the part to be decimated.
 196      * \param  pFieldName   name of the field used for decimation.
 197      * \param  pFieldIt     iteration (time step) of the field.
 198      * \param  pFilterName  name of the filter to be used.
 199      * \param  pTmed        threshold used for medium resolution.
 200      * \param  pTlow        threshold used for low resolution; tmed must be less than tlow
 201      * \param  pTadius      radius used to determine the neighbourhood.
 202      * \param  pBoxing      number of cells along each axis; must be >= 1; e.g. if 100 then acceleration grid will have 100*100*100 = 10**6 cells.
 203      * \return the name of each part.
 204      * \throw  RuntimeException if any error occurs.
 205      */
 206     std::vector<std::string> decimePartition(
 207         const char* pPartName,
 208         const char* pFieldName,
 209         int         pFieldIt,
 210         const char* pFilterName,
 211         double      pTmed,
 212         double      pTlow,
 213         double      pRadius,
 214         int         pBoxing);
 215
 216     /**
 217      * Returns useful information to configure decimation parameters.
 218      * Depends on part, field and filter: generic operation.
 219      * \param  pPartName     name of the part.
 220      * \param  pFieldName    name of the field used for decimation.
 221      * \param  pFieldIt      iteration (time step) of the field.
 222      * \param  pFilterName   name of the filter to be used.
 223      * \param  pFilterParams params to be used with the filter (depends on filter; this string will be parsed).
 224      */
 225     std::string evalDecimationParams(
 226         const char* pPartName,
 227         const char* pFieldName,
 228         int         pFieldIt,
 229         const char* pFilterName,
 230         const char* pFilterParams);
 231
 232
 233     //---------------------------------------------------------------------
 234     // I/O
 235     //---------------------------------------------------------------------
 236
 237     /**
 238      * Saves the associated MED file if necessary.
 239      * \param  pPath path where to save the file.
 240      * \throw  IOException if any i/o error occurs.
 241      */
 242     void save(const char* pPath);
 243
 244     /**
 245      * Dumps any Obj to the given output stream.
 246      * \param  pOs any output stream.
 247      * \param  pO  any Obj.
 248      * \return the output stream pOs.
 249      */
 250     friend std::ostream& operator<<(std::ostream& pOs, Obj& pO);
 251
 252 private:
 253
 254     /**
 255      * Returns the list of parts contained in the current distributed mesh.
 256      * \return the list of parts contained in the current distributed mesh.
 257      * \throw  IllegalStateException if the distributed mesh does not still exist.
 258      */
 259     std::vector<std::string> getListParts() const;
 260
 261 private:
 262
 263     std::string  mMEDfilename;     /**< Name of the MED file: sequential or distributed. */
 264     std::string  mMeshName;        /**< Mesh to be partitionned. */
 265     ObjState     mState;           /**< State of this object. */
 266     MeshDis*     mMeshDis;         /**< Distributed mesh. */
 267
 268
 269 private:
 270
 271     // do not allow copy constructor
 272     Obj(const Obj&);
 273
 274     // do not allow copy
 275     Obj& operator=(const Obj&);
 276
 277     // do not allow operator ==
 278     bool operator==(const Obj&);
 279
 280 }; // class Obj
 281
 282
 283 } // namespace MULTIPR
 284
 285
 286 #endif // MULTIPR_OBJ_HXX
 287
 288 // EOF