]> SALOME platform Git repositories - tools/medcoupling.git/blob - src/MEDCoupling/MEDCouplingField.cxx
Salome HOME
Little refactoring of progeny mechanism to avoid if.
[tools/medcoupling.git] / src / MEDCoupling / MEDCouplingField.cxx
1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19 // Author : Anthony Geay (CEA/DEN)
20
21 #include "MEDCouplingField.hxx"
22 #include "MEDCouplingMesh.hxx"
23 #include "MEDCouplingFieldDiscretization.hxx"
24
25 #include <sstream>
26
27 using namespace ParaMEDMEM;
28
29 bool MEDCouplingField::isEqualIfNotWhy(const MEDCouplingField *other, double meshPrec, double valsPrec, std::string& reason) const
30 {
31   if(!other)
32     throw INTERP_KERNEL::Exception("MEDCouplingField::isEqualIfNotWhy : other instance is NULL !");
33   std::ostringstream oss; oss.precision(15);
34   if(_name!=other->_name)
35     {
36       oss << "Field names differ : this name = \"" << _name << "\" and other name = \"" << other->_name << "\" !";
37       reason=oss.str();
38       return false;
39     }
40   if(_desc!=other->_desc)
41     {
42       oss << "Field descriptions differ : this description = \"" << _desc << "\" and other description = \"" << other->_desc << "\" !";
43       reason=oss.str();
44       return false;
45     }
46   if(_nature!=other->_nature)
47     {
48       oss << "Field nature differ : this nature = \"" << MEDCouplingNatureOfField::GetRepr(_nature) << "\" and other nature = \"" << MEDCouplingNatureOfField::GetRepr(other->_nature) << "\" !";
49       reason=oss.str();
50       return false;
51     }
52   if(!_type->isEqualIfNotWhy(other->_type,valsPrec,reason))
53     {
54       reason.insert(0,"Spatial discretizations differ :");
55       return false;
56     }
57   if(_mesh==0 && other->_mesh==0)
58     return true;
59   if(_mesh==0 || other->_mesh==0)
60     {
61       reason="Only one field between the two this and other has its underlying mesh defined !";
62       return false;
63     }
64   if(_mesh==other->_mesh)
65     return true;
66   bool ret=_mesh->isEqualIfNotWhy(other->_mesh,meshPrec,reason);
67   if(!ret)
68     reason.insert(0,"Underlying meshes of fields differ for the following reason : ");
69   return ret;
70 }
71
72 /*!
73  * Checks if \a this and another MEDCouplingField are fully equal.
74  *  \param [in] other - the field to compare with \a this one.
75  *  \param [in] meshPrec - precision used to compare node coordinates of the underlying mesh.
76  *  \param [in] valsPrec - precision used to compare field values.
77  *  \return bool - \c true if the two fields are equal, \c false else.
78  *  \throw If \a other is NULL.
79  */
80 bool MEDCouplingField::isEqual(const MEDCouplingField *other, double meshPrec, double valsPrec) const
81 {
82   std::string tmp;
83   return isEqualIfNotWhy(other,meshPrec,valsPrec,tmp);
84 }
85
86 /*!
87  * Checks if \a this and another MEDCouplingField are equal. The textual
88  * information like names etc. is not considered.
89  *  \param [in] other - the field to compare with \a this one.
90  *  \param [in] meshPrec - precision used to compare node coordinates of the underlying mesh.
91  *  \param [in] valsPrec - precision used to compare field values.
92  *  \return bool - \c true if the two fields are equal, \c false else.
93  *  \throw If \a other is NULL.
94  *  \throw If the spatial discretization of \a this field is NULL.
95  */
96 bool MEDCouplingField::isEqualWithoutConsideringStr(const MEDCouplingField *other, double meshPrec, double valsPrec) const
97 {
98   if(!other)
99     throw INTERP_KERNEL::Exception("MEDCouplingField::isEqualWithoutConsideringStr : input field is NULL !");
100   if(!_type)
101     throw INTERP_KERNEL::Exception("MEDCouplingField::isEqualWithoutConsideringStr : spatial discretization of this is NULL !");
102   if(!_type->isEqualWithoutConsideringStr(other->_type,valsPrec))
103     return false;
104   if(_nature!=other->_nature)
105     return false;
106   if(_mesh==0 && other->_mesh==0)
107     return true;
108   if(_mesh==0 || other->_mesh==0)
109     return false;
110   if(_mesh==other->_mesh)
111     return true;
112   return _mesh->isEqualWithoutConsideringStr(other->_mesh,meshPrec);
113 }
114
115 /*!
116  * This method states if 'this' and 'other' are compatibles each other before performing any treatment.
117  * This method is good for methods like : mergeFields.
118  * This method is not very demanding compared to areStrictlyCompatible that is better for operation on fields.
119  */
120 bool MEDCouplingField::areCompatibleForMerge(const MEDCouplingField *other) const
121 {
122   if(!other)
123     throw INTERP_KERNEL::Exception("MEDCouplingField::areCompatibleForMerge : input field is NULL !");
124   if(!_type->isEqual(other->_type,1.))
125     return false;
126   if(_nature!=other->_nature)
127     return false;
128   if(_mesh==other->_mesh)
129     return true;
130   return _mesh->areCompatibleForMerge(other->_mesh);
131 }
132
133 /*!
134  * This method is more strict than MEDCouplingField::areCompatibleForMerge method.
135  * This method is used for operation on fields to operate a first check before attempting operation.
136  */
137 bool MEDCouplingField::areStrictlyCompatible(const MEDCouplingField *other) const
138 {
139   if(!other)
140     throw INTERP_KERNEL::Exception("MEDCouplingField::areStrictlyCompatible : input field is NULL !");
141   if(!_type->isEqual(other->_type,1.e-12))
142     return false;
143   if(_nature!=other->_nature)
144     return false;
145   return _mesh==other->_mesh;
146 }
147
148 void MEDCouplingField::updateTime() const
149 {
150   if(_mesh)
151     updateTimeWith(*_mesh);
152   if(_type)
153     updateTimeWith(*_type);
154 }
155
156 std::size_t MEDCouplingField::getHeapMemorySizeWithoutChildren() const
157 {
158   std::size_t ret=0;
159   ret+=_name.capacity();
160   ret+=_desc.capacity();
161   return ret;
162 }
163
164 std::vector<const BigMemoryObject *> MEDCouplingField::getDirectChildrenWithNull() const
165 {
166   std::vector<const BigMemoryObject *> ret;
167   ret.push_back(_mesh);
168   ret.push_back((const MEDCouplingFieldDiscretization *)_type);
169   return ret;
170 }
171
172 /*!
173  * Returns a type of \ref MEDCouplingSpatialDisc "spatial discretization" of \a this
174  * field in terms of enum ParaMEDMEM::TypeOfField. 
175  * \return ParaMEDMEM::TypeOfField - the type of \a this field.
176  * \throw If the geometric type is empty.
177  */
178 TypeOfField MEDCouplingField::getTypeOfField() const
179 {
180   if(!((const MEDCouplingFieldDiscretization *)_type))
181     throw INTERP_KERNEL::Exception("MEDCouplingField::getTypeOfField : spatial discretization is null !");
182   return _type->getEnum();
183 }
184
185 /*!
186  * Returns the nature of \a this field. This information is very important during
187  * interpolation process using ParaMEDMEM::MEDCouplingRemapper or ParaMEDMEM::InterpKernelDEC.
188  * In other context than the two mentioned above, this attribute is unimportant. This
189  * attribute is not stored in the MED file.
190  * For more information of the semantics and the influence of this attribute to the
191  * result of interpolation, see
192  * - \ref NatureOfField
193  * - \ref TableNatureOfField "How interpolation coefficients depend on Field Nature"
194  */
195 NatureOfField MEDCouplingField::getNature() const
196 {
197   return _nature;
198 }
199
200 /*!
201  * Sets the nature of \a this field. This information is very important during
202  * interpolation process using ParaMEDMEM::MEDCouplingRemapper or ParaMEDMEM::InterpKernelDEC.
203  * In other context than the two mentioned above, this attribute is unimportant. This
204  * attribute is not stored in the MED file.
205  * For more information of the semantics and the influence of this attribute to the
206  * result of interpolation, see
207  * - \ref NatureOfField
208  * - \ref TableNatureOfField "How interpolation coefficients depend on Field Nature"
209  *
210  *  \param [in] nat - the nature of \a this field.
211  *  \throw If \a nat has an invalid value.
212  */
213 void MEDCouplingField::setNature(NatureOfField nat)
214 {
215   MEDCouplingNatureOfField::GetRepr(nat);//generate a throw if nat not recognized
216   _nature=nat;
217 }
218
219 /*!
220  * Returns coordinates of field location points that depend on 
221  * \ref MEDCouplingSpatialDisc "spatial discretization" of \a this field.
222  * - For a field on nodes, returns coordinates of nodes.
223  * - For a field on cells, returns barycenters of cells.
224  * - For a field on gauss points, returns coordinates of gauss points.
225  * 
226  *  \return DataArrayDouble * - a new instance of DataArrayDouble. The caller is to
227  *          delete this array using decrRef() as it is no more needed. 
228  *  \throw If the spatial discretization of \a this field is NULL.
229  *  \throw If the mesh is not set.
230  */
231 DataArrayDouble *MEDCouplingField::getLocalizationOfDiscr() const
232 {
233   if(!_mesh)
234     throw INTERP_KERNEL::Exception("MEDCouplingField::getLocalizationOfDiscr : No mesh set !");
235   if(!((const MEDCouplingFieldDiscretization *)_type))
236     throw INTERP_KERNEL::Exception("MEDCouplingField::getLocalizationOfDiscr : No spatial discretization set !");
237   return _type->getLocalizationOfDiscValues(_mesh);
238 }
239
240 /*!
241  * Returns a new MEDCouplingFieldDouble containing volumes of cells of a dual mesh whose
242  * cells are constructed around field location points (getLocalizationOfDiscr()) of \a this
243  * field. (In case of a field on cells, the dual mesh coincides with the underlying mesh).<br>
244  * For 1D cells, the returned field contains lengths.<br>
245  * For 2D cells, the returned field contains areas.<br>
246  * For 3D cells, the returned field contains volumes.
247  *  \param [in] isAbs - if \c true, the computed cell volume does not reflect cell
248  *         orientation, i.e. the volume is always positive.
249  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble.
250  *          The caller is to delete this array using decrRef() as
251  *          it is no more needed.
252  *  \throw If the mesh is not set.
253  *  \throw If the spatial discretization of \a this field is NULL.
254  *  \throw If the spatial discretization of \a this field is not well defined.
255  */
256
257 MEDCouplingFieldDouble *MEDCouplingField::buildMeasureField(bool isAbs) const
258 {
259   if(!_mesh)
260     throw INTERP_KERNEL::Exception("MEDCouplingField::buildMeasureField : no mesh defined !");
261   if(!((const MEDCouplingFieldDiscretization *)_type))
262     throw INTERP_KERNEL::Exception("MEDCouplingField::buildMeasureField : No spatial discretization set !");
263   return _type->getMeasureField(_mesh,isAbs);
264 }
265
266 /*!
267  * Sets the underlying mesh of \a this field.
268  * For examples of field construction, see \ref MEDCouplingFirstSteps3.
269  *  \param [in] mesh - the new underlying mesh.
270  */
271 void MEDCouplingField::setMesh(const MEDCouplingMesh *mesh)
272 {
273   if(mesh!=_mesh)
274     {
275       if(_mesh)
276         _mesh->decrRef();
277       _mesh=mesh;
278       declareAsNew();
279       if(_mesh)
280         {
281           _mesh->incrRef();
282           updateTimeWith(*_mesh);
283         }
284     }
285 }
286
287 /*!
288  * Sets localization of Gauss points for a given geometric type of cell.
289  *  \param [in] type - the geometric type of cell for which the Gauss localization is set.
290  *  \param [in] refCoo - coordinates of points of the reference cell. Size of this vector
291  *         must be \c nbOfNodesPerCell * \c dimOfType. 
292  *  \param [in] gsCoo - coordinates of Gauss points on the reference cell. Size of this vector
293  *         must be  _wg_.size() * \c dimOfType.
294  *  \param [in] wg - the weights of Gauss points.
295  *  \throw If \a this field is not on Gauss points.
296  *  \throw If the spatial discretization of \a this field is NULL.
297  *  \throw If the mesh is not set.
298  *  \throw If size of any vector do not match the \a type.
299  */
300 void MEDCouplingField::setGaussLocalizationOnType(INTERP_KERNEL::NormalizedCellType type, const std::vector<double>& refCoo,
301                                                   const std::vector<double>& gsCoo, const std::vector<double>& wg)
302 {
303   if(!_mesh)
304     throw INTERP_KERNEL::Exception("Mesh has to be set before calling setGaussLocalizationOnType method !");
305   if(!((const MEDCouplingFieldDiscretization *)_type))
306     throw INTERP_KERNEL::Exception("Spatial discretization not set ! Impossible to call setGaussLocalizationOnType method !");
307   _type->setGaussLocalizationOnType(_mesh,type,refCoo,gsCoo,wg);
308 }
309
310 /*!
311  * Sets localization of Gauss points for given cells specified by their ids.
312  *  \param [in] begin - an array of cell ids of interest.
313  *  \param [in] end - the end of \a begin, i.e. a pointer to its (last+1)-th element.
314  *  \param [in] refCoo - coordinates of points of the reference cell. Size of this vector
315  *         must be \c nbOfNodesPerCell * \c dimOfType. 
316  *  \param [in] gsCoo - coordinates of Gauss points on the reference cell. Size of this vector
317  *         must be  _wg_.size() * \c dimOfType.
318  *  \param [in] wg - the weights of Gauss points.
319  *  \throw If \a this field is not on Gauss points.
320  *  \throw If the spatial discretization of \a this field is NULL.
321  *  \throw If the mesh is not set.
322  *  \throw If size of any vector do not match the type of cell # \a begin[0].
323  *  \throw If type of any cell in \a begin differs from that of cell # \a begin[0].
324  *  \throw If the range [_begin_,_end_) is empty.
325  */
326 void MEDCouplingField::setGaussLocalizationOnCells(const int *begin, const int *end, const std::vector<double>& refCoo,
327                                                    const std::vector<double>& gsCoo, const std::vector<double>& wg)
328 {
329   if(!_mesh)
330     throw INTERP_KERNEL::Exception("Mesh has to be set before calling setGaussLocalizationOnCells method !");
331   if(!((const MEDCouplingFieldDiscretization *)_type))
332     throw INTERP_KERNEL::Exception("Spatial discretization not set ! Impossible to call setGaussLocalizationOnCells method !");
333   _type->setGaussLocalizationOnCells(_mesh,begin,end,refCoo,gsCoo,wg);
334 }
335
336 /*!
337  * Clears data on Gauss points localization.
338  *  \throw If \a this field is not on Gauss points.
339  *  \throw If the spatial discretization of \a this field is NULL.
340  */
341 void MEDCouplingField::clearGaussLocalizations()
342 {
343   if(!((const MEDCouplingFieldDiscretization *)_type))
344     throw INTERP_KERNEL::Exception("Spatial discretization not set ! Impossible to call clearGaussLocalizations method !");
345   _type->clearGaussLocalizations();
346 }
347
348 /*!
349  * Returns a reference to the Gauss localization object by its id.
350  * \warning This method is not const, so the returned object can be modified without any
351  *          problem.
352  *  \param [in] locId - the id of the Gauss localization object of interest.
353  *         It must be in range <em> 0 <= locId < getNbOfGaussLocalization() </em>.
354  *  \return \ref MEDCouplingGaussLocalization & - the Gauss localization object.
355  *  \throw If \a this field is not on Gauss points.
356  *  \throw If \a locId is not within the valid range.
357  *  \throw If the spatial discretization of \a this field is NULL.
358  */
359 MEDCouplingGaussLocalization& MEDCouplingField::getGaussLocalization(int locId)
360 {
361   if(!((const MEDCouplingFieldDiscretization *)_type))
362     throw INTERP_KERNEL::Exception("Spatial discretization not set ! Impossible to call getGaussLocalization method !");
363   return _type->getGaussLocalization(locId);
364 }
365
366 /*!
367  * Returns an id of the Gauss localization object corresponding to a given cell type.
368  *  \param [in] type - the cell type of interest.
369  *  \return int - the id of the Gauss localization object.
370  *  \throw If \a this field is not on Gauss points.
371  *  \throw If the spatial discretization of \a this field is NULL.
372  *  \throw If no Gauss localization object found for the given cell \a type.
373  *  \throw If more than one Gauss localization object found for the given cell \a type.
374  */
375 int MEDCouplingField::getGaussLocalizationIdOfOneType(INTERP_KERNEL::NormalizedCellType type) const
376 {
377   if(!((const MEDCouplingFieldDiscretization *)_type))
378     throw INTERP_KERNEL::Exception("Spatial discretization not set ! Impossible to call getGaussLocalizationIdOfOneType method !");
379   return _type->getGaussLocalizationIdOfOneType(type);
380 }
381
382 /*!
383  * Returns ids of Gauss localization objects corresponding to a given cell type.
384  *  \param [in] type - the cell type of interest.
385  *  \return std::set<int> - ids of the Gauss localization object.
386  *  \throw If \a this field is not on Gauss points.
387  *  \throw If the spatial discretization of \a this field is NULL
388  */
389 std::set<int> MEDCouplingField::getGaussLocalizationIdsOfOneType(INTERP_KERNEL::NormalizedCellType type) const
390 {
391   if(!((const MEDCouplingFieldDiscretization *)_type))
392     throw INTERP_KERNEL::Exception("Spatial discretization not set ! Impossible to call getGaussLocalizationIdsOfOneType method !");
393   return _type->getGaussLocalizationIdsOfOneType(type);
394 }
395
396 /*!
397  * Returns number of Gauss localization objects available. Implicitly all ids in
398  * [0,getNbOfGaussLocalization()) are valid Gauss localization ids. 
399  *  \return int - the number of available Gauss localization objects.
400  *  \throw If \a this field is not on Gauss points.
401  *  \throw If the spatial discretization of \a this field is NULL.
402  */
403 int MEDCouplingField::getNbOfGaussLocalization() const
404 {
405   if(!((const MEDCouplingFieldDiscretization *)_type))
406     throw INTERP_KERNEL::Exception("Spatial discretization not set ! Impossible to call getNbOfGaussLocalization method !");
407   return _type->getNbOfGaussLocalization();
408 }
409
410 /*!
411  * Returns an id of the Gauss localization object corresponding to a type of a given cell.
412  *  \param [in] cellId - an id of the cell of interest.
413  *  \return int - the id of the Gauss localization object.
414  *  \throw If \a this field is not on Gauss points.
415  *  \throw If the spatial discretization of \a this field is NULL.
416  *  \throw If no Gauss localization object found for the given cell.
417  */
418 int MEDCouplingField::getGaussLocalizationIdOfOneCell(int cellId) const
419 {
420   if(!((const MEDCouplingFieldDiscretization *)_type))
421     throw INTERP_KERNEL::Exception("Spatial discretization not set ! Impossible to call getGaussLocalizationIdOfOneCell method !");
422   return _type->getGaussLocalizationIdOfOneCell(cellId);
423 }
424
425 /*!
426  * Returns ids of cells that share the same Gauss localization given by its id.
427  *  \param [in] locId - the id of the Gauss localization object of interest. 
428  *         It must be in range <em> 0 <= locId < getNbOfGaussLocalization() </em>.
429  *  \param [in,out] cellIds - a vector returning ids of found cells. It is cleared before
430  *         filling in. It remains empty if no cells found.
431  *  \throw If \a this field is not on Gauss points.
432  *  \throw If \a locId is not within the valid range.
433  *  \throw If the spatial discretization of \a this field is NULL.
434  */
435 void MEDCouplingField::getCellIdsHavingGaussLocalization(int locId, std::vector<int>& cellIds) const
436 {
437   cellIds.clear();
438   if(!((const MEDCouplingFieldDiscretization *)_type))
439     throw INTERP_KERNEL::Exception("Spatial discretization not set ! Impossible to call getCellIdsHavingGaussLocalization method !");
440   _type->getCellIdsHavingGaussLocalization(locId,cellIds);
441 }
442
443 /*!
444  * Returns a reference to the Gauss localization object by its id.
445  * \warning This method is const, so the returned object is not apt for modification.
446  *  \param [in] locId - the id of the Gauss localization object of interest.
447  *         It must be in range <em> 0 <= locId < getNbOfGaussLocalization() </em>.
448  *  \return \ref const MEDCouplingGaussLocalization & - the Gauss localization object.
449  *  \throw If \a this field is not on Gauss points.
450  *  \throw If \a locId is not within the valid range.
451  *  \throw If the spatial discretization of \a this field is NULL.
452  */
453 const MEDCouplingGaussLocalization& MEDCouplingField::getGaussLocalization(int locId) const
454 {
455   if(!((const MEDCouplingFieldDiscretization *)_type))
456     throw INTERP_KERNEL::Exception("Spatial discretization not set ! Impossible to call getGaussLocalization method !");
457   return _type->getGaussLocalization(locId);
458 }
459
460 MEDCouplingField::~MEDCouplingField()
461 {
462   if(_mesh)
463     _mesh->decrRef();
464 }
465
466 MEDCouplingField::MEDCouplingField(MEDCouplingFieldDiscretization *type, NatureOfField nature):_nature(nature),_mesh(0),_type(type)
467 {
468 }
469
470 MEDCouplingField::MEDCouplingField(TypeOfField type):_nature(NoNature),_mesh(0),_type(MEDCouplingFieldDiscretization::New(type))
471 {
472 }
473
474 MEDCouplingField::MEDCouplingField(const MEDCouplingField& other, bool deepCopy):RefCountObject(other),_name(other._name),_desc(other._desc),_nature(other._nature),
475     _mesh(0),_type(0)
476 {
477   if(other._mesh)
478     {
479       _mesh=other._mesh;
480       _mesh->incrRef();
481     }
482   if(deepCopy)
483     _type=other._type->clone();
484   else
485     _type=other._type;
486 }
487
488 /*!
489  * Returns a new MEDCouplingMesh constituted by some cells of the underlying mesh of \a
490  * this filed, and returns ids of entities (nodes, cells, Gauss points) lying on the 
491  * specified cells. The cells to include to the result mesh are specified by an array of
492  * cell ids. The new mesh shares the coordinates array with the underlying mesh. 
493  *  \param [in] start - an array of cell ids to include to the result mesh.
494  *  \param [in] end - specifies the end of the array \a start, so that
495  *              the last value of \a start is \a end[ -1 ].
496  *  \param [out] di - a new instance of DataArrayInt holding the ids of entities (nodes,
497  *         cells, Gauss points). The caller is to delete this array using decrRef() as it
498  *         is no more needed.  
499  *  \return MEDCouplingMesh * - a new instance of MEDCouplingMesh. The caller is to
500  *         delete this mesh using decrRef() as it is no more needed. 
501  *  \throw If the spatial discretization of \a this field is NULL.
502  *  \throw If the mesh is not set.
503  * \sa buildSubMeshDataRange()
504  */
505 MEDCouplingMesh *MEDCouplingField::buildSubMeshData(const int *start, const int *end, DataArrayInt *&di) const
506 {
507   if(!((const MEDCouplingFieldDiscretization *)_type))
508     throw INTERP_KERNEL::Exception("Spatial discretization not set ! Impossible to call buildSubMeshData method !");
509   return _type->buildSubMeshData(_mesh,start,end,di);
510 }
511
512 /*!
513  * This method returns a submesh of 'mesh' instance constituting cell ids defined by a range given by the 3 following inputs \a begin, \a end and \a step.
514  * 
515  * \param [out] beginOut Valid only if \a di is NULL
516  * \param [out] endOut Valid only if \a di is NULL
517  * \param [out] stepOut Valid only if \a di is NULL
518  * \param [out] di is an array returned that specifies entity ids (nodes, cells, Gauss points... ) in array if no output range is foundable.
519  * 
520  * \sa MEDCouplingField::buildSubMeshData
521  */
522 MEDCouplingMesh *MEDCouplingField::buildSubMeshDataRange(int begin, int end, int step, int& beginOut, int& endOut, int& stepOut, DataArrayInt *&di) const
523 {
524   if(!((const MEDCouplingFieldDiscretization *)_type))
525     throw INTERP_KERNEL::Exception("Spatial discretization not set ! Impossible to call buildSubMeshDataRange method !");
526   return _type->buildSubMeshDataRange(_mesh,begin,end,step,beginOut,endOut,stepOut,di);
527 }
528
529 /*!
530  * This method returns tuples ids implied by the mesh selection of the  cell ids contained in array defined as an interval [start;end).
531  * \return a newly allocated DataArrayInt instance containing tuples ids.
532  */
533 DataArrayInt *MEDCouplingField::computeTupleIdsToSelectFromCellIds(const int *startCellIds, const int *endCellIds) const
534 {
535   if(!((const MEDCouplingFieldDiscretization *)_type))
536     throw INTERP_KERNEL::Exception("Spatial discretization not set ! Impossible to call computeTupleIdsToSelectFromCellIds method !");
537   return _type->computeTupleIdsToSelectFromCellIds(_mesh,startCellIds,endCellIds);
538 }
539
540 /*!
541  * Returns number of tuples expected regarding the spatial discretization of \a this
542  * field and number of entities in the underlying mesh. This method behaves exactly as MEDCouplingFieldDouble::getNumberOfTuples.
543  *  \return int - the number of expected tuples.
544  *  \throw If the spatial discretization of \a this field is NULL.
545  *  \throw If the mesh is not set.
546  */
547 int MEDCouplingField::getNumberOfTuplesExpected() const
548 {
549   if(!((const MEDCouplingFieldDiscretization *)_type))
550     throw INTERP_KERNEL::Exception("Spatial discretization not set ! Impossible to call getNumberOfTuplesExpected method !");
551   if(_mesh)
552     return _type->getNumberOfTuples(_mesh);
553   else
554     throw INTERP_KERNEL::Exception("MEDCouplingField::getNumberOfTuplesExpected : Empty mesh !");
555 }
556
557 void MEDCouplingField::setDiscretization(MEDCouplingFieldDiscretization *newDisc)
558 {
559   bool needUpdate=(const MEDCouplingFieldDiscretization *)_type!=newDisc;
560   _type=newDisc;
561   if(newDisc)
562     newDisc->incrRef();
563   if(needUpdate)
564     declareAsNew();
565 }
566
567 /*!
568  * Returns number of mesh entities in the underlying mesh of \a this field regarding the
569  * spatial discretization.
570  *  \return int - the number of mesh entities porting the field values.
571  *  \throw If the spatial discretization of \a this field is NULL.
572  *  \throw If the mesh is not set.
573  */
574 int MEDCouplingField::getNumberOfMeshPlacesExpected() const
575 {
576   if(!((const MEDCouplingFieldDiscretization *)_type))
577     throw INTERP_KERNEL::Exception("Spatial discretization not set ! Impossible to call getNumberOfMeshPlacesExpected method !");
578   if(_mesh)
579     return _type->getNumberOfMeshPlaces(_mesh);
580   else
581     throw INTERP_KERNEL::Exception("MEDCouplingField::getNumberOfMeshPlacesExpected : Empty mesh !");
582 }
583
584 /*!
585  * Copy tiny info (component names, name, description) but warning the underlying mesh is not renamed (for safety reason).
586  */
587 void MEDCouplingField::copyTinyStringsFrom(const MEDCouplingField *other)
588 {
589   if(other)
590     {
591       setName(other->_name);
592       setDescription(other->_desc);    
593     }
594 }
595
596 /*!
597  * This method computes the number of tuples a DataArrayDouble instance should have to build a correct MEDCouplingFieldDouble instance starting from a 
598  * submesh of a virtual mesh on which a substraction per type had been applied regarding the spatial discretization in \a this.
599  * 
600  * For spatial discretization \b not equal to ON_GAUSS_NE this method will make the hypothesis that any positive entity id in \a code \a idsPerType is valid.
601  * So in those cases attribute \a _mesh of \a this is ignored.
602  * 
603  * For spatial discretization equal to ON_GAUSS_NE \a _mesh attribute will be taken into account.
604  *
605  * The input code is those implemented in MEDCouplingUMesh::splitProfilePerType.
606  *
607  * \param [in] code - a code with format described above.
608  * \param [in] idsPerType - a list of subparts
609  * \throw If \a this has no spatial discretization set.
610  * \throw If input code point to invalid zones in spatial discretization.
611  * \throw If spatial discretization in \a this requires a mesh and those mesh is invalid (null,...)
612  */
613 int MEDCouplingField::getNumberOfTuplesExpectedRegardingCode(const std::vector<int>& code, const std::vector<const DataArrayInt *>& idsPerType) const
614 {
615   const MEDCouplingFieldDiscretization *t(_type);
616   if(!t)
617     throw INTERP_KERNEL::Exception("MEDCouplingField::getNumberOfTuplesExpectedRegardingCode : no spatial discretization set !");
618   return t->getNumberOfTuplesExpectedRegardingCode(code,idsPerType);
619 }