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          * Defines the mesh to be processed.
 102          * \param  pMeshName name of the mesh to be partitionned.
 103          */
 104         void setMesh(const char* pMeshName);
 105
 106         /**
 107          * Returns the list of meshes contained in the sequential MED file.
 108          * Assumes this object encapsulates a sequential MED file.
 109          * \return the list of meshes contained in the sequential MED file.
 110          */
 111         std::vector<std::string> getMeshes() const;
 112
 113         /**
 114          * Returns the list of fields contained in the sequential MED file.
 115          * Assumes this object encapsulates a sequential MED file.
 116          * \return the list of fields contained in the sequential MED file.
 117          */
 118         std::vector<std::string> getFields() const;
 119
 120         /**
 121          * Returns the number of timestamps for a given field.
 122          * Assumes this object encapsulates a sequential MED file.
 123          * \param  pFieldName name of any field.
 124          * \return the number of timestamps for a given field; 0 if field not found.
 125          */
 126         int getTimeStamps(const char* pFieldName) const;
 127
 128         /**
 129          * Returns the name of all partitions.
 130          * Assumes this object encapsulates a distributed MED file.
 131          * \return the name of all partitions.
 132          */
 133         std::vector<std::string> getParts() const;
 134
 135         /**
 136          * Returns all information about a part.
 137          * \param  pPartName name of the part.
 138          * \return all information about a part.
 139          */
 140         std::string getPartInfo(const char* pPartName) const;
 141
 142         /**
 143          * Removes all the part beginning by pPrefixPartName from the distributed MED file.
 144          * Example: if pPrefixPartName="PART_4" => remove "PART_4" and all sub-parts "PART_4_*", but not "PART41".
 145          * Assume this object encapsulates a distributed MED file.
 146          * \param  pPrefixPartName name of the part.
 147          */
 148         void removeParts(const char* pPrefixPartName);
 149
 150
 151         //---------------------------------------------------------------------
 152         // Algorithms
 153         //--------------------------------------------------------------------
 154
 155         /**
 156          * Creates a distributed MED file (v2.3) by extracting all the groups from the current mesh of the current MED sequential MED file.
 157          *         Assumes:
 158          *         - the file is in MED format and can be read using MED file v2.3.
 159          *         - the file is sequential (not a distributed MED).
 160          *         - the file only contains TETRA10 elements (dimension of space and mesh is 3).
 161          *         - the file have no profil.
 162          * \return the name of each part.
 163          * \throw  RuntimeException if any error occurs.
 164          */
 165         std::vector<std::string> partitionneDomaine();
 166
 167         /**
 168          * Creates a distributed MED file (V2.3) by splitting a group of a MED file previously created by partitionneDomaine.
 169          *         Assumes:
 170          *         - the file is a distributed MED file, previously created by partitionneDomaine()
 171          *           (=> each part only contain 1 mesh, TETRA10 elements only)
 172          *         - nbPart > 1
 173          * \param  pPartName     name of the part to be splitted.
 174          * \param  pNbParts      number of parts; must be > 1.
 175          * \param  pPartitionner use value 0=MULTIPR_METIS for Metis or 1=MULTIPR_SCOTCH for Scotch.
 176          * \return the name of each part.
 177          * \throw  RuntimeException if any error occurs.
 178          */
 179         std::vector<std::string> partitionneGrain(
 180                 const char* pPartName,
 181                 int         pNbParts,
 182                 int         pPartitionner=0);
 183
 184         /**
 185          * Creates 3 resolutions of the given part of a distributed MED file (V2.3).
 186          *         Assumes:
 187          *         - the file is a distributed MED file, previously created by partitionneDomaine() or partitionneGrain()
 188          *           (=> each part only contain 1 mesh, TETRA10 elements only)
 189          * \param  pPartName    name of the part to be decimated.
 190          * \param  pFieldName   name of the field used for decimation.
 191          * \param  pFieldIt     iteration (time step) of the field.
 192          * \param  pFilterName  name of the filter to be used.
 193          * \param  pTmed        threshold used for medium resolution.
 194          * \param  pTlow        threshold used for low resolution; tmed must be less than tlow
 195          * \param  pTadius      radius used to determine the neighbourhood.
 196          * \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.
 197          * \return the name of each part.
 198          * \throw  RuntimeException if any error occurs.
 199          */
 200         std::vector<std::string> decimePartition(
 201                 const char* pPartName,
 202                 const char* pFieldName,
 203                 int         pFieldIt,
 204                 const char* pFilterName,
 205                 double      pTmed,
 206                 double      pTlow,
 207                 double      pRadius,
 208                 int         pBoxing);
 209
 210         /**
 211          * Returns useful information to configure decimation parameters.
 212          * Depends on part, field and filter: generic operation.
 213          * \param  pPartName     name of the part.
 214          * \param  pFieldName    name of the field used for decimation.
 215          * \param  pFieldIt      iteration (time step) of the field.
 216          * \param  pFilterName   name of the filter to be used.
 217          * \param  pFilterParams params to be used with the filter (depends on filter; this string will be parsed).
 218          */
 219         std::string evalDecimationParams(
 220                 const char* pPartName,
 221                 const char* pFieldName,
 222                 int         pFieldIt,
 223                 const char* pFilterName,
 224                 const char* pFilterParams);
 225
 226
 227         //---------------------------------------------------------------------
 228         // I/O
 229         //---------------------------------------------------------------------
 230
 231         /**
 232          * Saves the associated MED file if necessary.
 233          * \param  pPath path where to save the file.
 234          * \throw  IOException if any i/o error occurs.
 235          */
 236         void save(const char* pPath);
 237
 238         /**
 239          * Dumps any Obj to the given output stream.
 240          * \param  pOs any output stream.
 241          * \param  pO  any Obj.
 242          * \return the output stream pOs.
 243          */
 244         friend std::ostream& operator<<(std::ostream& pOs, Obj& pO);
 245
 246 private:
 247
 248         /**
 249          * Returns the list of parts contained in the current distributed mesh.
 250          * \return the list of parts contained in the current distributed mesh.
 251          * \throw  IllegalStateException if the distributed mesh does not still exist.
 252          */
 253         std::vector<std::string> getListParts() const;
 254
 255 private:
 256
 257         std::string  mMEDfilename;     /**< Name of the MED file: sequential or distributed. */
 258         std::string  mMeshName;        /**< Mesh to be partitionned. */
 259         ObjState     mState;           /**< State of this object. */
 260         MeshDis*     mMeshDis;         /**< Distributed mesh. */
 261
 262
 263 private:
 264
 265         // do not allow copy constructor
 266         Obj(const Obj&);
 267
 268         // do not allow copy
 269         Obj& operator=(const Obj&);
 270
 271         // do not allow operator ==
 272         bool operator==(const Obj&);
 273
 274 }; // class Obj
 275
 276
 277 } // namespace MULTIPR
 278
 279
 280 #endif // MULTIPR_OBJ_HXX
 281
 282 // EOF