]> SALOME platform Git repositories - modules/multipr.git/blob - src/MULTIPR/MULTIPR_Obj.hxx
Salome HOME
*** empty log message ***
[modules/multipr.git] / 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