- Copyright © 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
- Copyright © 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-

+ + + + + +

+ +

- diff --git a/resources/CMakeLists.txt b/resources/CMakeLists.txt index 0f751fb1f..c654afba1 100644 --- a/resources/CMakeLists.txt +++ b/resources/CMakeLists.txt @@ -205,6 +205,7 @@ SET(MED_RESOURCES_FILES test_2D.sauve allPillesTest.sauv BDC-714.sauv + portico_3subs.sauv ) IF(MED_ENABLE_GUI) diff --git a/resources/Makefile.am b/resources/Makefile.am index f785fe87f..885f1b5d8 100644 --- a/resources/Makefile.am +++ b/resources/Makefile.am @@ -208,7 +208,8 @@ dist_salomeres_DATA = \ blow5_ascii_pd_thickness \ test_2D.sauve \ allPillesTest.sauv \ - BDC-714.sauv + BDC-714.sauv \ + portico_3subs.sauv if !MED_ENABLE_MICROMED nodist_salomeres_SCRIPTS = MEDCatalog.xml SalomeApp.xml diff --git a/resources/portico_3subs.sauv b/resources/portico_3subs.sauv new file mode 100644 index 000000000..d672a118f --- /dev/null +++ b/resources/portico_3subs.sauv @@ -0,0 +1,182 @@ + ENREGISTREMENT DE TYPE 4 + NIVEAU 18 NIVEAU ERREUR 0 DIMENSION 3 + DENSITE 0.00000E+00 + ENREGISTREMENT DE TYPE 7 + NOMBRE INFO CASTEM2000 8 + IFOUR 2 NIFOUR 0 IFOMOD 2 IECHO 1 IIMPI 0 IOSPI 0 ISOTYP 1 + NSDPGE 0 + ENREGISTREMENT DE TYPE 2 + PILE NUMERO 1NBRE OBJETS NOMMES 6NBRE OBJETS 6 + PBAS POT1 POT2 POUTL STOT EL1 + 4 1 2 3 5 6 + 2 0 0 2 2 + 0 0 + 1 2 2 3 + 2 0 0 2 3 + 0 0 0 + 4 5 5 6 6 7 + 2 0 0 2 1 + 0 + 3 7 + 1 0 0 1 2 + 0 0 + 1 4 + 2 0 0 2 6 + 0 0 0 0 0 0 + 1 2 2 3 4 5 5 6 6 7 + 3 7 + 1 0 0 1 7 + 0 0 0 0 0 0 0 + 1 2 4 5 6 3 7 + ENREGISTREMENT DE TYPE 2 + PILE NUMERO 32NBRE OBJETS NOMMES 4NBRE OBJETS 7 + 0P0 0P1 1P0 1P1 + 1 4 3 7 + 7 + 1 2 6 3 4 5 7 + ENREGISTREMENT DE TYPE 2 + PILE NUMERO 33NBRE OBJETS NOMMES 0NBRE OBJETS 1 + 96 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 5.00000000000000E-01 5.00000000000000E-01 1.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 1.00000000000000E+00 0.00000000000000E+00 3.33333333333333E-01 + 3.33333333333333E-01 1.00000000000000E+00 0.00000000000000E+00 + 6.66666666666667E-01 3.33333333333333E-01 0.00000000000000E+00 + 0.00000000000000E+00 1.00000000000000E+00 0.00000000000000E+00 + 1.00000000000000E+00 0.00000000000000E+00 1.00000000000000E+00 + 0.00000000000000E+00 3.00000000000000E+03 -2.00000000000000E+04 + 6.00000000000000E+03 0.00000000000000E+00 1.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 1.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 1.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 1.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 1.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 1.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 1.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 1.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 1.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 -1.00000000000000E+03 + -1.00000000000000E+03 1.00000000000000E+03 0.00000000000000E+00 + ENREGISTREMENT DE TYPE 2 + PILE NUMERO 39NBRE OBJETS NOMMES 1NBRE OBJETS 1 + CHAM1D + 1 + 3 2 6 11 + CONTRAINTES + -1 27665 6 0 0 0 -1 0 5 -2 + 27882 6 0 0 0 -2 0 5 -3 27931 + 6 0 0 0 -3 0 5 + 19363 19664 19888 + + 27833 27840 27847 27854 27861 27868 + EFFX EFFY EFFZ MOMX MOMY MOMZ + REAL*8 REAL*8 REAL*8 REAL*8 + REAL*8 REAL*8 + 2 2 0 0 + -7.68749999999959E-03 -7.68749999999959E-03 -4.56249999999959E-03 + -4.56249999999959E-03 + 2 2 0 0 + -6.11141334691317E-07 -6.11141334691317E-07 -6.11141334690612E-07 + -6.11141334690612E-07 + 2 2 0 0 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 + 2 2 0 0 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 + 2 2 0 0 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 + 2 2 0 0 + 1.32422443924838E-04 1.32728014592183E-04 1.32728014592184E-04 + 1.33033585259529E-04 + 27826 27903 27889 27917 27910 27896 + EFFX EFFY EFFZ MOMX MOMY MOMZ + REAL*8 REAL*8 REAL*8 REAL*8 + REAL*8 REAL*8 + 2 3 0 0 + -8.20833333333293E-03 -8.20833333333293E-03 -6.12499999999960E-03 + -6.12499999999960E-03 -4.04166666666627E-03 -4.04166666666627E-03 + 2 3 0 0 + 6.11141334689149E-07 6.11141334689149E-07 6.11141334689393E-07 + 6.11141334689393E-07 6.11141334688905E-07 6.11141334688905E-07 + 2 3 0 0 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 2 3 0 0 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 2 3 0 0 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 2 3 0 0 + -1.32422443922787E-04 -1.32626157701017E-04 -1.32626157701017E-04 + -1.32829871479247E-04 -1.32829871479247E-04 -1.33033585257476E-04 + 27651 27952 27938 27966 27959 27945 + EFFX EFFY EFFZ MOMX MOMY MOMZ + REAL*8 REAL*8 REAL*8 REAL*8 + REAL*8 REAL*8 + 2 1 0 0 + -6.11141334691013E-07 -6.11141334691013E-07 + 2 1 0 0 + 0.00000000000000E+00 0.00000000000000E+00 + 2 1 0 0 + -5.81088996365331E-15 -5.81088996365331E-15 + 2 1 0 0 + 0.00000000000000E+00 0.00000000000000E+00 + 2 1 0 0 + -3.66966414738893E-04 -3.66966414744704E-04 + 2 1 0 0 + 0.00000000000000E+00 0.00000000000000E+00 + ENREGISTREMENT DE TYPE 2 + PILE NUMERO 40NBRE OBJETS NOMMES 0NBRE OBJETS 3 + 2 2 + 1.00000000000000E+00 -1.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 1.00000000000000E+00 -5.00000000000000E-01 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 1.00000000000000E+00 0.00000000000000E+00 5.00000000000000E-01 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 1.00000000000000E+00 1.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + -5.00000000000000E-01 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 1.00000000000000E+00 + 5.00000000000000E-01 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 1.00000000000000E+00 + 2 2 + 1.00000000000000E+00 -1.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 1.00000000000000E+00 -5.00000000000000E-01 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 1.00000000000000E+00 0.00000000000000E+00 5.00000000000000E-01 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 1.00000000000000E+00 1.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + -5.00000000000000E-01 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 1.00000000000000E+00 + 5.00000000000000E-01 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 1.00000000000000E+00 + 2 2 + 1.00000000000000E+00 -1.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 1.00000000000000E+00 -5.00000000000000E-01 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 1.00000000000000E+00 0.00000000000000E+00 5.00000000000000E-01 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 1.00000000000000E+00 1.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 + -5.00000000000000E-01 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 0.00000000000000E+00 1.00000000000000E+00 + 5.00000000000000E-01 0.00000000000000E+00 0.00000000000000E+00 + 0.00000000000000E+00 1.00000000000000E+00 + ENREGISTREMENT DE TYPE 5 +LABEL_AUTOMATIQUE_2 diff --git a/src/MEDCalculator/Swig/CMakeLists.txt b/src/MEDCalculator/Swig/CMakeLists.txt index 4e1497993..144b81042 100644 --- a/src/MEDCalculator/Swig/CMakeLists.txt +++ b/src/MEDCalculator/Swig/CMakeLists.txt @@ -47,9 +47,12 @@ INSTALL(TARGETS medcalculatorspython DESTINATION ${MED_salomelib_LIBS}) SET_SOURCE_FILES_PROPERTIES(MEDCalculator.i PROPERTIES CPLUSPLUS ON) SET_SOURCE_FILES_PROPERTIES(MEDCalculator.i PROPERTIES SWIG_DEFINITIONS "-shadow") +IF(NUMPY_STATUS) + SET(SWIG_MODULE_MEDCalculator_EXTRA_FLAGS -DWITH_NUMPY) +ENDIF(NUMPY_STATUS) SWIG_ADD_MODULE(MEDCalculator python MEDCalculator.i) SWIG_LINK_LIBRARIES(MEDCalculator ${PYTHON_LIBS} medcalculator) -SET_TARGET_PROPERTIES(_MEDCalculator PROPERTIES COMPILE_FLAGS "${PLATFORM_DEFINITIONS}") +SET_TARGET_PROPERTIES(_MEDCalculator PROPERTIES COMPILE_FLAGS "${PLATFORM_DEFINITIONS} ${PYTHON_DEFINITIONS}") IF(${MACHINE} STREQUAL WINDOWS) SET_TARGET_PROPERTIES(_MEDCalculator PROPERTIES DEBUG_OUTPUT_NAME _MEDCalculator_d) diff --git a/src/MEDCoupling/MEDCouplingField.cxx b/src/MEDCoupling/MEDCouplingField.cxx index 967caf414..e189f32be 100644 --- a/src/MEDCoupling/MEDCouplingField.cxx +++ b/src/MEDCoupling/MEDCouplingField.cxx @@ -69,12 +69,30 @@ bool MEDCouplingField::isEqualIfNotWhy(const MEDCouplingField *other, double mes return ret; } +/*! + * Checks if \a this and another MEDCouplingField are fully equal. + * \param [in] other - the field to compare with \a this one. + * \param [in] meshPrec - precision used to compare node coordinates of the underlying mesh. + * \param [in] valsPrec - precision used to compare field values. + * \return bool - \c true if the two fields are equal, \c false else. + * \throw If \a other is NULL. + */ bool MEDCouplingField::isEqual(const MEDCouplingField *other, double meshPrec, double valsPrec) const { std::string tmp; return isEqualIfNotWhy(other,meshPrec,valsPrec,tmp); } +/*! + * Checks if \a this and another MEDCouplingField are equal. The textual + * information like names etc. is not considered. + * \param [in] other - the field to compare with \a this one. + * \param [in] meshPrec - precision used to compare node coordinates of the underlying mesh. + * \param [in] valsPrec - precision used to compare field values. + * \return bool - \c true if the two fields are equal, \c false else. + * \throw If \a other is NULL. + * \throw If the spatial discretization of \a this field is NULL. + */ bool MEDCouplingField::isEqualWithoutConsideringStr(const MEDCouplingField *other, double meshPrec, double valsPrec) const { if(!other) @@ -147,15 +165,25 @@ std::size_t MEDCouplingField::getHeapMemorySize() const return ret; } +/*! + * Returns a type of \ref MEDCouplingSpatialDisc "spatial discretization" of \a this + * field in terms of enum ParaMEDMEM::TypeOfField. + * \return ParaMEDMEM::TypeOfField - the type of \a this field. + */ TypeOfField MEDCouplingField::getTypeOfField() const { return _type->getEnum(); } /*! - * This method returns the nature of field. This information is very important during interpolation process using ParaMEDMEM::MEDCouplingRemapper or ParaMEDMEM::InterpKernelDEC. - * In other context than the two mentioned before this attribute of the field is not sensitive. This attribute is not store in MED file in MEDLoader. - * More information of the semantic, and the consequence of this attribute in the result of the interpolation, is available \ref NatureOfField "here". + * Returns the nature of \a this field. This information is very important during + * interpolation process using ParaMEDMEM::MEDCouplingRemapper or ParaMEDMEM::InterpKernelDEC. + * In other context than the two mentioned above, this attribute is unimportant. This + * attribute is not stored in the MED file. + * For more information of the semantics and the influence of this attribute to the + * result of interpolation, see + * - \ref NatureOfField + * - \ref TableNatureOfField "How interpolation coefficients depend on Field Nature" */ NatureOfField MEDCouplingField::getNature() const { @@ -163,9 +191,17 @@ NatureOfField MEDCouplingField::getNature() const } /*! - * This method set the nature of field in \b this.This information is very important during interpolation process using ParaMEDMEM::MEDCouplingRemapper or ParaMEDMEM::InterpKernelDEC. - * In other context than the two mentioned before this attribute of the field is not sensitive. This attribute is not store in MED file in MEDLoader. - * More information of the semantic, and the consequence of this attribute in the result of the interpolation, is available \ref TableNatureOfField "here". + * Sets the nature of \a this field. This information is very important during + * interpolation process using ParaMEDMEM::MEDCouplingRemapper or ParaMEDMEM::InterpKernelDEC. + * In other context than the two mentioned above, this attribute is unimportant. This + * attribute is not stored in the MED file. + * For more information of the semantics and the influence of this attribute to the + * result of interpolation, see + * - \ref NatureOfField + * - \ref TableNatureOfField "How interpolation coefficients depend on Field Nature" + * + * \param [in] nat - the nature of \a this field. + * \throw If \a nat has an invalid value. */ void MEDCouplingField::setNature(NatureOfField nat) throw(INTERP_KERNEL::Exception) { @@ -174,10 +210,16 @@ void MEDCouplingField::setNature(NatureOfField nat) throw(INTERP_KERNEL::Excepti } /*! - * This method returns is case of success an instance of DataArrayDouble the user is in reponsability to deal with. - * If 'this->_mesh' is not set an exception will be thrown. - * For a field on node the array of coords will be returned. For a field on cell a ParaMEDMEM::DataArrayDouble instance - * containing the barycenter of cells will be returned. And for a field on gauss point the explicit position of gauss points. + * Returns coordinates of field location points that depend on + * \ref MEDCouplingSpatialDisc "spatial discretization" of \a this field. + * - For a field on nodes, returns coordinates of nodes. + * - For a field on cells, returns barycenters of cells. + * - For a field on gauss points, returns coordinates of gauss points. + * + * \return DataArrayDouble * - a new instance of DataArrayDouble. The caller is to + * delete this array using decrRef() as it is no more needed. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. */ DataArrayDouble *MEDCouplingField::getLocalizationOfDiscr() const throw(INTERP_KERNEL::Exception) { @@ -189,9 +231,22 @@ DataArrayDouble *MEDCouplingField::getLocalizationOfDiscr() const throw(INTERP_K } /*! - * This method retrieves the measure field of 'this'. If no '_mesh' is defined an exception will be thrown. - * Warning the retrieved field life cycle is the responsability of caller. + * Returns a new MEDCouplingFieldDouble containing volumes of cells of a dual mesh whose + * cells are constructed around field location points (getLocalizationOfDiscr()) of \a this + * field. (In case of a field on cells, the dual mesh coincides with the underlying mesh).
+ * For 1D cells, the returned field contains lengths.
+ * For 2D cells, the returned field contains areas.
+ * For 3D cells, the returned field contains volumes. + * \param [in] isAbs - if \c true, the computed cell volume does not reflect cell + * orientation, i.e. the volume is always positive. + * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. + * The caller is to delete this array using decrRef() as + * it is no more needed. + * \throw If the mesh is not set. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the spatial discretization of \a this field is not well defined. */ + MEDCouplingFieldDouble *MEDCouplingField::buildMeasureField(bool isAbs) const throw(INTERP_KERNEL::Exception) { if(!_mesh) @@ -201,6 +256,11 @@ MEDCouplingFieldDouble *MEDCouplingField::buildMeasureField(bool isAbs) const th return _type->getMeasureField(_mesh,isAbs); } +/*! + * Sets the underlying mesh of \a this field. + * For examples of field construction, see \ref MEDCouplingFirstSteps3. + * \param [in] mesh - the new underlying mesh. + */ void MEDCouplingField::setMesh(const MEDCouplingMesh *mesh) { if(mesh!=_mesh) @@ -218,12 +278,17 @@ void MEDCouplingField::setMesh(const MEDCouplingMesh *mesh) } /*! - * This method sets gauss localization by geometric type. - * @param type geometric type on which the gauss localization will be set. - * @param refCoo is the reference coordinates of the specified element. Its size has to be equal to nbOfNodesPerCell*dimOfType - * @param gsCoo are the coordinates of Gauss points in reference element specified by 'refCoo'. Its size must be equal to wg.size()*dimOfType - * @param wg are the weights on Gauss points. The size of this array is used to determine the number of Gauss point in the element. - * @throw when size of 'RefCoo' is not valid regarding 'type' parameter, it throws too when the mesh is not set before or if it is not a field on Gauss points. + * Sets localization of Gauss points for a given geometric type of cell. + * \param [in] type - the geometric type of cell for which the Gauss localization is set. + * \param [in] refCoo - coordinates of points of the reference cell. Size of this vector + * must be \c nbOfNodesPerCell * \c dimOfType. + * \param [in] gsCoo - coordinates of Gauss points on the reference cell. Size of this vector + * must be _wg_.size() * \c dimOfType. + * \param [in] wg - the weights of Gauss points. + * \throw If \a this field is not on Gauss points. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. + * \throw If size of any vector do not match the \a type. */ void MEDCouplingField::setGaussLocalizationOnType(INTERP_KERNEL::NormalizedCellType type, const std::vector& refCoo, const std::vector& gsCoo, const std::vector& wg) throw(INTERP_KERNEL::Exception) @@ -236,14 +301,20 @@ void MEDCouplingField::setGaussLocalizationOnType(INTERP_KERNEL::NormalizedCellT } /*! - * This method sets on ids defined by [begin;end) their gauss localization. This method checks the coherency of cells ids in [begin;end) and 'refCoo' size. - * If an incoherence appears an exception will be thrown and no seting will be performed. - * An exception is thrown too if [begin,end) has a size lesser than 1. - * - * @param refCoo is the reference coordinates of the specified element. Its size has to be equal to nbOfNodesPerCell*dimOfType - * @param gsCoo are the coordinates of Gauss points in reference element specified by 'refCoo'. Its size must be equal to wg.size()*dimOfType - * @param wg are the weights on Gauss points. The size of this array is used to determine the number of Gauss point in the element. - * @throw when size of 'RefCoo' is not valid regarding cells in [begin,end) parameters, it throws too when the mesh is not set before or if it is not a field on Gauss points. + * Sets localization of Gauss points for given cells specified by their ids. + * \param [in] begin - an array of cell ids of interest. + * \param [in] end - the end of \a begin, i.e. a pointer to its (last+1)-th element. + * \param [in] refCoo - coordinates of points of the reference cell. Size of this vector + * must be \c nbOfNodesPerCell * \c dimOfType. + * \param [in] gsCoo - coordinates of Gauss points on the reference cell. Size of this vector + * must be _wg_.size() * \c dimOfType. + * \param [in] wg - the weights of Gauss points. + * \throw If \a this field is not on Gauss points. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. + * \throw If size of any vector do not match the type of cell # \a begin[0]. + * \throw If type of any cell in \a begin differs from that of cell # \a begin[0]. + * \throw If the range [_begin_,_end_) is empty. */ void MEDCouplingField::setGaussLocalizationOnCells(const int *begin, const int *end, const std::vector& refCoo, const std::vector& gsCoo, const std::vector& wg) throw(INTERP_KERNEL::Exception) @@ -256,7 +327,10 @@ void MEDCouplingField::setGaussLocalizationOnCells(const int *begin, const int * } /*! - * This method resets all Gauss loalizations if any. + * Clears data on Gauss points localization. + * \throw If \a this field is not on Gauss points. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. */ void MEDCouplingField::clearGaussLocalizations() { @@ -268,10 +342,16 @@ void MEDCouplingField::clearGaussLocalizations() } /*! - * This method returns reference to the Gauss localization object corresponding to 'locId' id. - * This method throws an exception if there is no mesh, invalid FieldDescription (different from Gauss) and if 'locId' is invalid because out of range given by - * MEDCouplingField::getNbOfGaussLocalization method. - * Warning this method is not const, so the returned object could be modified without any problem. + * Returns a reference to the Gauss localization object by its id. + * \warning This method is not const, so the returned object can be modified without any + * problem. + * \param [in] locId - the id of the Gauss localization object of interest. + * It must be in range 0 <= locId < getNbOfGaussLocalization() . + * \return \ref MEDCouplingGaussLocalization & - the Gauss localization object. + * \throw If \a this field is not on Gauss points. + * \throw If \a locId is not within the valid range. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. */ MEDCouplingGaussLocalization& MEDCouplingField::getGaussLocalization(int locId) throw(INTERP_KERNEL::Exception) { @@ -283,9 +363,14 @@ MEDCouplingGaussLocalization& MEDCouplingField::getGaussLocalization(int locId) } /*! - * This method returns reference to the Gauss localization object corresponding to 'locId' id. - * This method throws an exception if there is no mesh, invalid FieldDescription (different from Gauss) and if several localization ids have been found - * for a type. + * Returns an id of the Gauss localization object corresponding to a given cell type. + * \param [in] type - the cell type of interest. + * \return int - the id of the Gauss localization object. + * \throw If \a this field is not on Gauss points. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. + * \throw If no Gauss localization object found for the given cell \a type. + * \throw If more than one Gauss localization object found for the given cell \a type. */ int MEDCouplingField::getGaussLocalizationIdOfOneType(INTERP_KERNEL::NormalizedCellType type) const throw(INTERP_KERNEL::Exception) { @@ -296,6 +381,14 @@ int MEDCouplingField::getGaussLocalizationIdOfOneType(INTERP_KERNEL::NormalizedC return _type->getGaussLocalizationIdOfOneType(type); } +/*! + * Returns ids of Gauss localization objects corresponding to a given cell type. + * \param [in] type - the cell type of interest. + * \return std::set - ids of the Gauss localization object. + * \throw If \a this field is not on Gauss points. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. + */ std::set MEDCouplingField::getGaussLocalizationIdsOfOneType(INTERP_KERNEL::NormalizedCellType type) const throw(INTERP_KERNEL::Exception) { if(!_mesh) @@ -306,8 +399,12 @@ std::set MEDCouplingField::getGaussLocalizationIdsOfOneType(INTERP_KERNEL:: } /*! - * This method returns number of Gauss localization available. Implicitely all ids in [0,getNbOfGaussLocalization()) is a valid Gauss localisation id. - * This method throws an exception if there is no mesh, invalid FieldDescription (different from Gauss) + * Returns number of Gauss localization objects available. Implicitly all ids in + * [0,getNbOfGaussLocalization()) are valid Gauss localization ids. + * \return int - the number of available Gauss localization objects. + * \throw If \a this field is not on Gauss points. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. */ int MEDCouplingField::getNbOfGaussLocalization() const throw(INTERP_KERNEL::Exception) { @@ -319,9 +416,13 @@ int MEDCouplingField::getNbOfGaussLocalization() const throw(INTERP_KERNEL::Exce } /*! - * This method returns an id of Gauss localization in [0,getNbOfGaussLocalization()) that corresponds to the localization of the cell specified by its cellId. - * This methods throws an exception if there is no mesh, invalid FieldDescription (different from Gauss) or if at the cell with id 'cellId' in this->_mesh no - * Gauss localization has been set. + * Returns an id of the Gauss localization object corresponding to a type of a given cell. + * \param [in] cellId - an id of the cell of interest. + * \return int - the id of the Gauss localization object. + * \throw If \a this field is not on Gauss points. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. + * \throw If no Gauss localization object found for the given cell. */ int MEDCouplingField::getGaussLocalizationIdOfOneCell(int cellId) const throw(INTERP_KERNEL::Exception) { @@ -333,11 +434,15 @@ int MEDCouplingField::getGaussLocalizationIdOfOneCell(int cellId) const throw(IN } /*! - * This method returns all cellIds that share the same Gauss localization given by 'locId' parameter (in range [0,getNbOfGaussLocalization()) ). - * If no cells fit the Gauss localization given by 'locId' cellIds will be returned empty. - * @param locId input that specifies the id of Gauss localization. - * @param cellIds output parameter, that will contain the result if this method succeds. This parameter is systematically cleared when called. - * @throw if there is no mesh, invalid FieldDescription (different from Gauss) or if locId not in [0,getNbOfGaussLocalization()) + * Returns ids of cells that share the same Gauss localization given by its id. + * \param [in] locId - the id of the Gauss localization object of interest. + * It must be in range 0 <= locId < getNbOfGaussLocalization() . + * \param [in,out] cellIds - a vector returning ids of found cells. It is cleared before + * filling in. It remains empty if no cells found. + * \throw If \a this field is not on Gauss points. + * \throw If \a locId is not within the valid range. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. */ void MEDCouplingField::getCellIdsHavingGaussLocalization(int locId, std::vector& cellIds) const throw(INTERP_KERNEL::Exception) { @@ -350,10 +455,15 @@ void MEDCouplingField::getCellIdsHavingGaussLocalization(int locId, std::vector< } /*! - * This method returns reference to the Gauss localization object corresponding to 'locId' id. - * This method throws an exception if there is no mesh, invalid FieldDescription (different from Gauss) and if 'locId' is invalid because out of range given by - * MEDCouplingField::getNbOfGaussLocalization method. - * Warning this method is const. + * Returns a reference to the Gauss localization object by its id. + * \warning This method is const, so the returned object is not apt for modification. + * \param [in] locId - the id of the Gauss localization object of interest. + * It must be in range 0 <= locId < getNbOfGaussLocalization() . + * \return \ref const MEDCouplingGaussLocalization & - the Gauss localization object. + * \throw If \a this field is not on Gauss points. + * \throw If \a locId is not within the valid range. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. */ const MEDCouplingGaussLocalization& MEDCouplingField::getGaussLocalization(int locId) const throw(INTERP_KERNEL::Exception) { @@ -393,10 +503,21 @@ MEDCouplingField::MEDCouplingField(const MEDCouplingField& other, bool deepCopy) } /*! - * This method returns a submesh of 'mesh' instance constituting cell ids contained in array defined as an interval [start;end). - * @param di is an array returned that specifies entity ids (nodes, cells, Gauss points... ) in array. - * - * \sa MEDCouplingField::buildSubMeshDataRange + * Returns a new MEDCouplingMesh constituted by some cells of the underlying mesh of \a + * this filed, and returns ids of entities (nodes, cells, Gauss points) lying on the + * specified cells. The cells to include to the result mesh are specified by an array of + * cell ids. The new mesh shares the coordinates array with the underlying mesh. + * \param [in] start - an array of cell ids to include to the result mesh. + * \param [in] end - specifies the end of the array \a start, so that + * the last value of \a start is \a end[ -1 ]. + * \param [out] di - a new instance of DataArrayInt holding the ids of entities (nodes, + * cells, Gauss points). The caller is to delete this array using decrRef() as it + * is no more needed. + * \return MEDCouplingMesh * - a new instance of MEDCouplingMesh. The caller is to + * delete this mesh using decrRef() as it is no more needed. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. + * \sa buildSubMeshDataRange() */ MEDCouplingMesh *MEDCouplingField::buildSubMeshData(const int *start, const int *end, DataArrayInt *&di) const { @@ -434,8 +555,11 @@ DataArrayInt *MEDCouplingField::computeTupleIdsToSelectFromCellIds(const int *st } /*! - * This method returns number of tuples expected regarding its discretization and its _mesh attribute. - * This method expected a not null _mesh instance. If null, an exception will be thrown. + * Returns number of tuples expected regarding the spatial discretization of \a this + * field and number of entities in the underlying mesh. + * \return int - the number of expected tuples. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. */ int MEDCouplingField::getNumberOfTuplesExpected() const throw(INTERP_KERNEL::Exception) { @@ -458,8 +582,11 @@ void MEDCouplingField::setDiscretization(MEDCouplingFieldDiscretization *newDisc } /*! - * This method returns number of mesh placed expected regarding its discretization and its _mesh attribute. - * This method expected a not null _mesh instance. If null, an exception will be thrown. + * Returns number of mesh entities in the underlying mesh of \a this field regarding the + * spatial discretization. + * \return int - the number of mesh entities porting the field values. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. */ int MEDCouplingField::getNumberOfMeshPlacesExpected() const throw(INTERP_KERNEL::Exception) { diff --git a/src/MEDCoupling/MEDCouplingFieldDouble.cxx b/src/MEDCoupling/MEDCouplingFieldDouble.cxx index 2bf4c48b8..4b4399ca0 100644 --- a/src/MEDCoupling/MEDCouplingFieldDouble.cxx +++ b/src/MEDCoupling/MEDCouplingFieldDouble.cxx @@ -35,27 +35,46 @@ using namespace ParaMEDMEM; + /*! - * Creates a new instance of MEDCouplingFieldDouble of given type. The caller is responsable for the returned field. - * - * \param [in] type type of spatial discretization of a created field (\ref ParaMEDMEM::ON_CELLS "ON_CELLS", \ref ParaMEDMEM::ON_NODES "ON_NODES", \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT", \ref ParaMEDMEM::ON_GAUSS_NE "ON_GAUSS_NE", \ref ParaMEDMEM::ON_NODES_KR "ON_NODES_KR"). - * \param [in] td type of time discretization of a created field (\ref ParaMEDMEM::NO_TIME "NO_TIME", \ref ParaMEDMEM::ONE_TIME "ONE_TIME", \ref ParaMEDMEM::LINEAR_TIME "LINEAR_TIME", \ref ParaMEDMEM::CONST_ON_TIME_INTERVAL "CONST_ON_TIME_INTERVAL"). - - * \return a newly allocated field the caller should deal with. - */ -MEDCouplingFieldDouble *MEDCouplingFieldDouble::New(TypeOfField type, TypeOfTimeDiscretization td) + * Creates a new MEDCouplingFieldDouble, of given spatial type and time discretization. + * For more info, see \ref MEDCouplingFirstSteps3. + * \param [in] type - the type of spatial discretization of the created field, one of + * (\ref ParaMEDMEM::ON_CELLS "ON_CELLS", + * \ref ParaMEDMEM::ON_NODES "ON_NODES", + * \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT", + * \ref ParaMEDMEM::ON_GAUSS_NE "ON_GAUSS_NE", + * \ref ParaMEDMEM::ON_NODES_KR "ON_NODES_KR"). + * \param [in] td - the type of time discretization of the created field, one of + * (\ref ParaMEDMEM::NO_TIME "NO_TIME", + * \ref ParaMEDMEM::ONE_TIME "ONE_TIME", + * \ref ParaMEDMEM::LINEAR_TIME "LINEAR_TIME", + * \ref ParaMEDMEM::CONST_ON_TIME_INTERVAL "CONST_ON_TIME_INTERVAL"). + * \return MEDCouplingFieldDouble* - a new instance of MEDCouplingFieldDouble. The + * caller is to delete this field using decrRef() as it is no more needed. + */ +MEDCouplingFieldDouble* MEDCouplingFieldDouble::New(TypeOfField type, TypeOfTimeDiscretization td) { return new MEDCouplingFieldDouble(type,td); } /*! - * Creates a new instance of MEDCouplingFieldDouble of given type. The caller is responsable for the returned field. - * ** WARINING : This method do not deeply copy neither mesh nor spatial discretization. Only a shallow copy (reference) is done for mesh and spatial discretization ! ** - * - * \param [in] ft \ref MEDCouplingFieldTemplatesPage "field template" defining its spatial discretization and supporting mesh. - * \param [in] td type of time discretization of a created field (\ref ParaMEDMEM::NO_TIME "NO_TIME", \ref ParaMEDMEM::ONE_TIME "ONE_TIME", \ref ParaMEDMEM::LINEAR_TIME "LINEAR_TIME", \ref ParaMEDMEM::CONST_ON_TIME_INTERVAL "CONST_ON_TIME_INTERVAL") - - * \return a newly allocated field the caller should deal with. + * Creates a new MEDCouplingFieldDouble, of a given time discretization and with a + * spatial type and supporting mesh copied from a given + * \ref MEDCouplingFieldTemplatesPage "field template". + * For more info, see \ref MEDCouplingFirstSteps3. + * \warning This method does not deeply copy neither the mesh nor the spatial + * discretization. Only a shallow copy (reference) is done for the mesh and the spatial + * discretization! + * \param [in] ft - the \ref MEDCouplingFieldTemplatesPage "field template" defining + * the spatial discretization and the supporting mesh. + * \param [in] td - the type of time discretization of the created field, one of + * (\ref ParaMEDMEM::NO_TIME "NO_TIME", + * \ref ParaMEDMEM::ONE_TIME "ONE_TIME", + * \ref ParaMEDMEM::LINEAR_TIME "LINEAR_TIME", + * \ref ParaMEDMEM::CONST_ON_TIME_INTERVAL "CONST_ON_TIME_INTERVAL"). + * \return MEDCouplingFieldDouble* - a new instance of MEDCouplingFieldDouble. The + * caller is to delete this field using decrRef() as it is no more needed. */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::New(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td) { @@ -63,8 +82,7 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::New(const MEDCouplingFieldTempla } /*! - * Sets time \a unit of \a this field. - * + * Sets a time \a unit of \a this field. For more info, see \ref MEDCouplingFirstSteps3. * \param [in] unit \a unit (string) in which time is measured. */ void MEDCouplingFieldDouble::setTimeUnit(const char *unit) @@ -74,7 +92,6 @@ void MEDCouplingFieldDouble::setTimeUnit(const char *unit) /*! * Returns a time unit of \a this field. - * * \return a string describing units in which time is measured. */ const char *MEDCouplingFieldDouble::getTimeUnit() const @@ -95,20 +112,25 @@ void MEDCouplingFieldDouble::synchronizeTimeWithSupport() throw(INTERP_KERNEL::E } /*! - * This method performs a copy of \a this **without any copy of the underlying mesh** ( see warning section of this method). - * The copy of arrays is deep if \b recDeepCpy equals to true, no copy of arrays is done if \b recDeepCpy equals to false. - * - * \c clone(false) is rather dedicated for advanced users that want to limit the amount of memory. - * - * It allows the user to perform methods - * MEDCouplingFieldDouble::AddFields, MEDCouplingFieldDouble::MultiplyFields with \a this and the returned field. + * Returns a new MEDCouplingFieldDouble which is a copy of \a this one. The data + * of \a this field is copied either deep or shallow depending on \a recDeepCpy + * parameter. But the underlying mesh is always shallow copied. + * Data that can be copied either deeply or shallow are: + * - \ref MEDCouplingTemporalDisc "temporal discretization" data that holds array(s) + * of field values, + * - \ref MEDCouplingSpatialDisc "a spatial discretization". * - * \warning The \b underlying \b mesh of the returned field is \b always the same (same pointer) than \a this **whatever the value** of \a recDeepCpy parameter. - * If the user wants to duplicated deeply the underlying mesh he should call MEDCouplingFieldDouble::cloneWithMesh method or MEDCouplingFieldDouble::deepCpy instead. - * - * \param [in] recDeepCpy specifies if underlying arrays in \a this should be copied or only attached to the returned field. - * \return a newly allocated MEDCouplingFieldDouble instance that the caller should deal with. - * \sa ParaMEDMEM::MEDCouplingFieldDouble::cloneWithMesh(bool recDeepCpy) const + * \c clone(false) is rather dedicated for advanced users that want to limit the amount + * of memory. It allows the user to perform methods like operator+(), operator*() + * etc. with \a this and the returned field. If the user wants to duplicate deeply the + * underlying mesh he should call cloneWithMesh() method or deepCpy() instead. + * \warning The underlying \b mesh of the returned field is **always the same** + * (pointer) as \a this one **whatever the value** of \a recDeepCpy parameter. + * \param [in] recDeepCpy - if \c true, the copy of the underlying data arrays is + * deep, else all data arrays of \a this field are shared by the new field. + * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The + * caller is to delete this field using decrRef() as it is no more needed. + * \sa cloneWithMesh() */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::clone(bool recDeepCpy) const { @@ -116,17 +138,25 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::clone(bool recDeepCpy) const } /*! - * This method behaves exactly like MEDCouplingFieldDouble::clone method **except that here the underlying mesh is systematically ** - * (whatever the value of the input parameter \a recDeepCpy) **deeply duplicated**. - * - * The result of \c cloneWithMesh(true) is exactly the same than calling \ref MEDCouplingFieldDouble::deepCpy "deepCpy". + * Returns a new MEDCouplingFieldDouble which is a copy of \a this one. The data + * of \a this field is copied either deep or shallow depending on \a recDeepCpy + * parameter. But the underlying mesh is always deep copied. + * Data that can be copied either deeply or shallow are: + * - \ref MEDCouplingTemporalDisc "temporal discretization" data that holds array(s) + * of field values, + * - \ref MEDCouplingSpatialDisc "a spatial discretization". * - * So the resulting field of this call cannot be called with \a this with the following methods MEDCouplingFieldDouble::AddFields, MEDCouplingFieldDouble::MultiplyFields ... - * To avoid to deep copy the underlying mesh the user should call MEDCouplingFieldDouble::clone method instead. - - * \param [in] recDeepCpy specifies if underlying arrays in \a this should be copied or only attached to the returned field. - * \return a newly allocated MEDCouplingFieldDouble instance that the caller should deal with. - * \sa ParaMEDMEM::MEDCouplingFieldDouble::clone(bool recDeepCpy) const + * This method behaves exactly like clone() except that here the underlying **mesh is + * always deeply duplicated**, whatever the value \a recDeepCpy parameter. + * The result of \c cloneWithMesh(true) is exactly the same as that of deepCpy(). + * So the resulting field can not be used together with \a this one in the methods + * like operator+(), operator*() etc. To avoid deep copying the underlying mesh, + * the user can call clone(). + * \param [in] recDeepCpy - if \c true, the copy of the underlying data arrays is + * deep, else all data arrays of \a this field are shared by the new field. + * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The + * caller is to delete this field using decrRef() as it is no more needed. + * \sa clone() */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::cloneWithMesh(bool recDeepCpy) const { @@ -140,13 +170,15 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::cloneWithMesh(bool recDeepCpy) c } /*! - * This method performs a deepCpy of \a this (**mesh included**)! - * So the resulting field of this call cannot be called with \a this with following methods MEDCouplingFieldDouble::AddFields, MEDCouplingFieldDouble::MultiplyFields ... - * To avoid deep copying the underlying mesh the user should call MEDCouplingFieldDouble::clone method instead. - * This method is exactly equivalent to MEDCouplingFieldDouble::cloneWithMesh called with parameter true. - * - * \return a newly allocated MEDCouplingFieldDouble instance that the caller should deal with. - * \sa ParaMEDMEM::MEDCouplingFieldDouble::cloneWithMesh(bool recDeepCpy) const + * Returns a new MEDCouplingFieldDouble which is a deep copy of \a this one **including + * the mesh**. + * The result of this method is exactly the same as that of \c cloneWithMesh(true). + * So the resulting field can not be used together with \a this one in the methods + * like operator+(), operator*() etc. To avoid deep copying the underlying mesh, + * the user can call clone(). + * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The + * caller is to delete this field using decrRef() as it is no more needed. + * \sa cloneWithMesh() */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::deepCpy() const { @@ -154,16 +186,23 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::deepCpy() const } /*! - * TODOC + * Creates a new MEDCouplingFieldDouble of given + * \ref MEDCouplingTemporalDisc "temporal discretization". The result field either + * shares the data array(s) with \a this field, or holds a deep copy of it, depending on + * \a deepCopy parameter. But the underlying \b mesh is always **shallow copied**. + * \param [in] td - the type of time discretization of the created field, one of + * (\ref ParaMEDMEM::NO_TIME "NO_TIME", + * \ref ParaMEDMEM::ONE_TIME "ONE_TIME", + * \ref ParaMEDMEM::LINEAR_TIME "LINEAR_TIME", + * \ref ParaMEDMEM::CONST_ON_TIME_INTERVAL "CONST_ON_TIME_INTERVAL"). + * \param [in] deepCopy - if \c true, the copy of the underlying data arrays is + * deep, else all data arrays of \a this field are shared by the new field. + * \return MEDCouplingFieldDouble* - a new instance of MEDCouplingFieldDouble. The + * caller is to delete this field using decrRef() as it is no more needed. * - * \param [in] td type of time discretization of a created field (\ref ParaMEDMEM::NO_TIME "NO_TIME", \ref ParaMEDMEM::ONE_TIME "ONE_TIME", \ref ParaMEDMEM::LINEAR_TIME "LINEAR_TIME", \ref ParaMEDMEM::CONST_ON_TIME_INTERVAL "CONST_ON_TIME_INTERVAL"). - * \param [in] deepCopy specifies if underlying arrays in \a this should be copied or only attached to the returned field. - * \return a newly allocated MEDCouplingFieldDouble instance that the caller should deal with. - * - * \ref cpp_mcfielddouble_buildnewtimereprfromthis "Here a C++ example." - - * \ref py_mcfielddouble_buildnewtimereprfromthis "Here a Python example." - * \sa ParaMEDMEM::MEDCouplingFieldDouble::clone(bool recDeepCpy) const + * \ref cpp_mcfielddouble_buildNewTimeReprFromThis "Here is a C++ example."
+ * \ref py_mcfielddouble_buildNewTimeReprFromThis "Here is a Python example." + * \sa clone() */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::buildNewTimeReprFromThis(TypeOfTimeDiscretization td, bool deepCopy) const { @@ -179,7 +218,11 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::buildNewTimeReprFromThis(TypeOfT } /*! - * Copy tiny info (component names, name, description) but warning the underlying mesh is not renamed (for safety reason). + * Copies tiny info (component names, name and description) from an \a other field to + * \a this one. + * \warning The underlying mesh is not renamed (for safety reason). + * \param [in] other - the field to copy the tiny info from. + * \throw If \a this->getNumberOfComponents() != \a other->getNumberOfComponents() */ void MEDCouplingFieldDouble::copyTinyStringsFrom(const MEDCouplingField *other) throw(INTERP_KERNEL::Exception) { @@ -192,8 +235,11 @@ void MEDCouplingFieldDouble::copyTinyStringsFrom(const MEDCouplingField *other) } /*! - * Copy only times, order, iteration from other. The underlying mesh is not impacted by this method. - * Arrays are not impacted too. + * Copies only times, order and iteration from an \a other field to + * \a this one. The underlying mesh is not impacted by this method. + * Arrays are not impacted neither. + * \param [in] other - the field to tiny attributes from. + * \throw If \a this->getNumberOfComponents() != \a other->getNumberOfComponents() */ void MEDCouplingFieldDouble::copyTinyAttrFrom(const MEDCouplingFieldDouble *other) throw(INTERP_KERNEL::Exception) { @@ -210,6 +256,19 @@ void MEDCouplingFieldDouble::copyAllTinyAttrFrom(const MEDCouplingFieldDouble *o copyTinyAttrFrom(other); } +/*! + * Returns a string describing \a this field. This string is outputted by \c print + * Python command. The string includes info on + * - name, + * - description, + * - \ref MEDCouplingSpatialDisc "spatial discretization", + * - \ref MEDCouplingTemporalDisc "time discretization", + * - \ref NatureOfField, + * - components, + * - mesh. + * + * \return std::string - the string describing \a this field. + */ std::string MEDCouplingFieldDouble::simpleRepr() const { std::ostringstream ret; @@ -247,6 +306,18 @@ std::string MEDCouplingFieldDouble::simpleRepr() const return ret.str(); } +/*! + * Returns a string describing \a this field. The string includes info on + * - name, + * - description, + * - \ref MEDCouplingSpatialDisc "spatial discretization", + * - \ref MEDCouplingTemporalDisc "time discretization", + * - components, + * - mesh, + * - contents of data arrays. + * + * \return std::string - the string describing \a this field. + */ std::string MEDCouplingFieldDouble::advancedRepr() const { std::ostringstream ret; @@ -307,6 +378,16 @@ bool MEDCouplingFieldDouble::isEqualIfNotWhy(const MEDCouplingField *other, doub return true; } +/*! + * Checks equality of \a this and \a other field. Only numeric data is considered, + * i.e. names, description etc are not compared. + * \param [in] other - the field to compare with. + * \param [in] meshPrec - a precision used to compare node coordinates of meshes. + * \param [in] valsPrec - a precision used to compare data arrays of the two fields. + * \return bool - \c true if the two fields are equal, \c false else. + * \throw If \a other == NULL. + * \throw If the spatial discretization of \a this field is NULL. + */ bool MEDCouplingFieldDouble::isEqualWithoutConsideringStr(const MEDCouplingField *other, double meshPrec, double valsPrec) const { const MEDCouplingFieldDouble *otherC=dynamic_cast(other); @@ -399,8 +480,24 @@ bool MEDCouplingFieldDouble::areCompatibleForMeld(const MEDCouplingFieldDouble * } /*! - * This method performs a clone of mesh and a renumbering of underlying cells of it. The number of cells remains the same. - * The values of field are impacted in consequence to have the same geometrical field. + * Permutes values of \a this field according to a given permutation array for cells + * renumbering. The underlying mesh is deeply copied and its cells are also permuted. + * The number of cells remains the same; for that the permutation array \a old2NewBg + * should not contain equal ids. + * \param [in] old2NewBg - the permutation array in "Old to New" mode. Its length is + * to be equal to \a this->getMesh()->getNumberOfCells(). + * \param [in] check - if \c true, \a old2NewBg is transformed to a new permutation + * array, so that its maximal cell id to correspond to (be less than) the number + * of cells in mesh. This new array is then used for the renumbering. If \a + * check == \c false, \a old2NewBg is used as is, that is less secure as validity + * of ids in \a old2NewBg is not checked. + * \throw If the mesh is not set. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If \a check == \c true and \a old2NewBg contains equal ids. + * \throw If mesh nature does not allow renumbering (e.g. structured mesh). + * + * \ref cpp_mcfielddouble_renumberCells "Here is a C++ example".
+ * \ref py_mcfielddouble_renumberCells "Here is a Python example". */ void MEDCouplingFieldDouble::renumberCells(const int *old2NewBg, bool check) throw(INTERP_KERNEL::Exception) { @@ -412,10 +509,25 @@ void MEDCouplingFieldDouble::renumberCells(const int *old2NewBg, bool check) thr } /*! - * \b WARNING : use this method with lot of care ! - * This method performs half job of MEDCouplingFieldDouble::renumberCells. That is to say no permutation of cells is done on underlying mesh. - * That is to say, the field content is changed by this method. The reason of this method is only for multi-field instances lying on the same mesh to - * avoid a systematic duplication and renumbering of _mesh attribute. + * Permutes values of \a this field according to a given permutation array for cells + * renumbering. The underlying mesh is \b not permuted. + * The number of cells remains the same; for that the permutation array \a old2NewBg + * should not contain equal ids. + * This method performs a part of job of renumberCells(). The reasonable use of this + * method is only for multi-field instances lying on the same mesh to avoid a + * systematic duplication and renumbering of _mesh attribute. + * \warning Use this method with a lot of care! + * \param [in] old2NewBg - the permutation array in "Old to New" mode. Its length is + * to be equal to \a this->getMesh()->getNumberOfCells(). + * \param [in] check - if \c true, \a old2NewBg is transformed to a new permutation + * array, so that its maximal cell id to correspond to (be less than) the number + * of cells in mesh. This new array is then used for the renumbering. If \a + * check == \c false, \a old2NewBg is used as is, that is less secure as validity + * of ids in \a old2NewBg is not checked. + * \throw If the mesh is not set. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If \a check == \c true and \a old2NewBg contains equal ids. + * \throw If mesh nature does not allow renumbering (e.g. structured mesh). */ void MEDCouplingFieldDouble::renumberCellsWithoutMesh(const int *old2NewBg, bool check) throw(INTERP_KERNEL::Exception) { @@ -433,10 +545,21 @@ void MEDCouplingFieldDouble::renumberCellsWithoutMesh(const int *old2NewBg, bool } /*! - * This method performs a clone of mesh and a renumbering of underlying nodes of it. The number of nodes remains not compulsory the same as renumberCells method. - * The values of field are impacted in consequence to have the same geometrical field. + * Permutes values of \a this field according to a given permutation array for node + * renumbering. The underlying mesh is deeply copied and its nodes are also permuted. + * The number of nodes can change, contrary to renumberCells(). + * \param [in] old2NewBg - the permutation array in "Old to New" mode. Its length is + * to be equal to \a this->getMesh()->getNumberOfNodes(). + * \param [in] eps - a precision used to compare field values at merged nodes. If + * the values differ more than \a eps, an exception is thrown. + * \throw If the mesh is not set. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If \a check == \c true and \a old2NewBg contains equal ids. + * \throw If mesh nature does not allow renumbering (e.g. structured mesh). + * \throw If values at merged nodes deffer more than \a eps. * - * \sa MEDCouplingFieldDouble::renumberNodesWithoutMesh + * \ref cpp_mcfielddouble_renumberNodes "Here is a C++ example".
+ * \ref py_mcfielddouble_renumberNodes "Here is a Python example". */ void MEDCouplingFieldDouble::renumberNodes(const int *old2NewBg, double eps) throw(INTERP_KERNEL::Exception) { @@ -452,11 +575,26 @@ void MEDCouplingFieldDouble::renumberNodes(const int *old2NewBg, double eps) thr } /*! - * \b WARNING : use this method with lot of care ! - * ** WARNING : in case of throw the content in array can be partially modified until the exception raises ** - * This method performs half job of MEDCouplingFieldDouble::renumberNodes. That is to say no permutation of nodes is done on underlying mesh. - * That is to say, the field content is changed by this method. As the API suggests, this method can performs the half job of nodes contraction. - * That's why an epsilon is given to specify a threshold of error in case of two nodes are merged but the difference of values on these nodes are higher than \a eps. + * Permutes values of \a this field according to a given permutation array for nodes + * renumbering. The underlying mesh is \b not permuted. + * The number of nodes can change, contrary to renumberCells(). + * A given epsilon specifies a threshold of error in case of two nodes are merged but + * the difference of values on these nodes are higher than \a eps. + * This method performs a part of job of renumberNodes(), excluding node renumbering + * in mesh. The reasonable use of this + * method is only for multi-field instances lying on the same mesh to avoid a + * systematic duplication and renumbering of _mesh attribute. + * \warning Use this method with a lot of care! + * \warning In case of an exception thrown, the contents of the data array can be + * partially modified until the exception occurs. + * \param [in] old2NewBg - the permutation array in "Old to New" mode. Its length is + * to be equal to \a this->getMesh()->getNumberOfNodes(). + * \param [in] newNbOfNodes - a number of nodes in the mesh after renumbering. + * \param [in] eps - a precision used to compare field values at merged nodes. If + * the values differ more than \a eps, an exception is thrown. + * \throw If the mesh is not set. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If values at merged nodes deffer more than \a eps. */ void MEDCouplingFieldDouble::renumberNodesWithoutMesh(const int *old2NewBg, int newNbOfNodes, double eps) throw(INTERP_KERNEL::Exception) { @@ -470,10 +608,17 @@ void MEDCouplingFieldDouble::renumberNodesWithoutMesh(const int *old2NewBg, int } /*! - * This method makes the assumption that the default array is set. If not an exception will be thrown. - * This method is usable only if the default array has exactly one component. If not an exception will be thrown too. - * This method returns all tuples ids that fit the range [vmin,vmax]. - * The caller has the responsability of the returned DataArrayInt. + * Returns all tuple ids of \a this scalar field that fit the range [\a vmin, + * \a vmax]. This method calls DataArrayDouble::getIdsInRange(). + * \param [in] vmin - a lower boundary of the range. Tuples with values less than \a + * vmin are not included in the result array. + * \param [in] vmax - an upper boundary of the range. Tuples with values more than \a + * vmax are not included in the result array. + * \return DataArrayInt * - a new instance of DataArrayInt holding ids of selected + * tuples. The caller is to delete this array using decrRef() as it is no + * more needed. + * \throw If the data array is not set. + * \throw If \a this->getNumberOfComponents() != 1. */ DataArrayInt *MEDCouplingFieldDouble::getIdsInRange(double vmin, double vmax) const throw(INTERP_KERNEL::Exception) { @@ -483,23 +628,34 @@ DataArrayInt *MEDCouplingFieldDouble::getIdsInRange(double vmin, double vmax) co } /*! - * Builds a newly created field, that the caller will have the responsability to deal with (decrRef). + * Builds a newly created field, that the caller will have the responsability to deal with (decrRef()). * This method makes the assumption that the field is correctly defined when this method is called, no check of this will be done. - * This method returns a restriction of \a this so that only tuples id specified in 'part' will be contained in returned field. - * Parameter 'part' specifies \b cell \b ids \b whatever \b the \b spatial \b discretization of \a this (ON_CELLS, ON_NODES, ON_GAUSS_PT, ON_GAUSS_NE) + * This method returns a restriction of \a this so that only tuples with ids specified in \a part will be contained in the returned field. + * Parameter \a part specifies **cell ids whatever the spatial discretization of this** ( + * \ref ParaMEDMEM::ON_CELLS "ON_CELLS", + * \ref ParaMEDMEM::ON_NODES "ON_NODES", + * \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT", + * \ref ParaMEDMEM::ON_GAUSS_NE "ON_GAUSS_NE", + * \ref ParaMEDMEM::ON_NODES_KR "ON_NODES_KR"). * - * If \a this is a field on cell lying on a mesh that have 10 cells. If part contains following cellIds [3,7,6]. - * In this case the returned field will lie on mesh having 3 cells and the returned field will contain 3 tuples. - * Tuple#0 of return field will refer to the cell#0 of returned mesh. The cell #0 of returned mesh will be equal to the cell#3 of 'this->getMesh()' - * Tuple#1 of return field will refer to the cell#1 of returned mesh. The cell #1 of returned mesh will be equal to the cell#7 of 'this->getMesh()' - * Tuple#2 of return field will refer to the cell#2 of returned mesh. The cell #2 of returned mesh will be equal to the cell#6 of 'this->getMesh()' + * For example, \a this is a field on cells lying on a mesh that have 10 cells, \a part contains following cell ids [3,7,6]. + * Then the returned field will lie on mesh having 3 cells and the returned field will contain 3 tuples.
+ * Tuple #0 of the result field will refer to the cell #0 of returned mesh. The cell #0 of returned mesh will be equal to the cell #3 of \a this->getMesh().
+ * Tuple #1 of the result field will refer to the cell #1 of returned mesh. The cell #1 of returned mesh will be equal to the cell #7 of \a this->getMesh().
+ * Tuple #2 of the result field will refer to the cell #2 of returned mesh. The cell #2 of returned mesh will be equal to the cell #6 of \a this->getMesh(). * - * If \a this is field on node lying on a mesh that have 10 cells and 11 nodes for example. If part contains following cellIds [3,7,6]. - * \a this is currently contains 11 tuples. If the restriction of mesh to 3 cells leads to a mesh with 6 nodes, the returned field, - * will contain 6 tuples and this field will lie on this restricted mesh. + * Let, for example, \a this be a field on nodes lying on a mesh that have 10 cells and 11 nodes, and \a part contains following cellIds [3,7,6]. + * Thus \a this currently contains 11 tuples. If the restriction of mesh to 3 cells leads to a mesh with 6 nodes, then the returned field + * will contain 6 tuples and \a this field will lie on this restricted mesh. * - * \sa MEDCouplingFieldDouble::buildSubPartRange + * \param [in] part - an array of cell ids to include to the result field. + * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The caller is to delete this field using decrRef() as it is no more needed. + * + * \ref cpp_mcfielddouble_subpart1 "Here is a C++ example".
+ * \ref py_mcfielddouble_subpart1 "Here is a Python example". + * \sa MEDCouplingFieldDouble::buildSubPartRange */ + MEDCouplingFieldDouble *MEDCouplingFieldDouble::buildSubPart(const DataArrayInt *part) const throw(INTERP_KERNEL::Exception) { if(part==0) @@ -509,31 +665,32 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::buildSubPart(const DataArrayInt /*! * Builds a newly created field, that the caller will have the responsability to deal with. - * \n This method makes the assumption that the field \a this is correctly defined when this method is called (\c this->checkCoherency() returns without any exception thrown), **no check of this will be done**. - * \n This method returns a restriction of \a this so that only tuples id specified in [ \a partBg , \a partEnd ) will be contained in returned field. - * \n Parameter [\a partBg, \a partEnd ) specifies \b cell \b ids \b whatever \b the \b spatial \b discretization of \a this - * (\ref ParaMEDMEM::ON_CELLS "ON_CELLS", \ref ParaMEDMEM::ON_NODES "ON_CELLS", \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT", \ref ParaMEDMEM::ON_GAUSS_NE "ON_GAUSS_NE") + * \n This method makes the assumption that \a this field is correctly defined when this method is called (\a this->checkCoherency() returns without any exception thrown), **no check of this will be done**. + * \n This method returns a restriction of \a this so that only tuple ids specified in [ \a partBg , \a partEnd ) will be contained in the returned field. + * \n Parameter [\a partBg, \a partEnd ) specifies **cell ids whatever the spatial discretization** of \a this ( + * \ref ParaMEDMEM::ON_CELLS "ON_CELLS", + * \ref ParaMEDMEM::ON_NODES "ON_NODES", + * \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT", + * \ref ParaMEDMEM::ON_GAUSS_NE "ON_GAUSS_NE", + * \ref ParaMEDMEM::ON_NODES_KR "ON_NODES_KR"). * - * If \a this is a field on cell lying on a mesh that have 10 cells. If part contains following cellIds [3,7,6]. - * In this case the returned field will lie on mesh having 3 cells and the returned field will contain 3 tuples. + * For example, \a this is a field on cells lying on a mesh that have 10 cells, \a partBg contains the following cell ids [3,7,6]. + * Then the returned field will lie on mesh having 3 cells and will contain 3 tuples. + *- Tuple #0 of the result field will refer to the cell #0 of returned mesh. The cell #0 of returned mesh will be equal to the cell #3 of \a this->getMesh(). + *- Tuple #1 of the result field will refer to the cell #1 of returned mesh. The cell #1 of returned mesh will be equal to the cell #7 of \a this->getMesh(). + *- Tuple #2 of the result field will refer to the cell #2 of returned mesh. The cell #2 of returned mesh will be equal to the cell #6 of \a this->getMesh(). * - *- Tuple#0 of return field will refer to the cell#0 of returned mesh. The cell #0 of returned mesh will be equal to the cell#3 of \c this->getMesh() - *- Tuple#1 of return field will refer to the cell#1 of returned mesh. The cell #1 of returned mesh will be equal to the cell#7 of \c this->getMesh() - *- Tuple#2 of return field will refer to the cell#2 of returned mesh. The cell #2 of returned mesh will be equal to the cell#6 of \c this->getMesh() + * Let, for example, \a this be a field on nodes lying on a mesh that have 10 cells and 11 nodes, and \a partBg contains following cellIds [3,7,6]. + * Thus \a this currently contains 11 tuples. If the restriction of mesh to 3 cells leads to a mesh with 6 nodes, then the returned field + * will contain 6 tuples and \a this field will lie on this restricted mesh. * - * If \a this is field on node lying on a mesh that have 10 cells and 11 nodes for example. So \a this is currently contains 11 tuples. - * \n If part contains following cellIds [3,7,6]. - * \n If the restriction of mesh to 3 cells leads to a mesh with 6 nodes, the returned field, - * will contain 6 tuples (and same number of components \c this->getArray()->getNumberOfComponents() ) and this field will lie on this restricted mesh. - * - * \param [in] partBg start (included) of input range cell ids to select [ \a partBg, \a partEnd ) - * \param [in] partEnd end (not included) of input range cell ids to select [ \a partBg, \a partEnd ) + * \param [in] partBg - start (included) of input range of cell ids to select [ \a partBg, \a partEnd ) + * \param [in] partEnd - end (not included) of input range of cell ids to select [ \a partBg, \a partEnd ) * \return a newly allocated field the caller should deal with. * - * \throw if there is presence of an invalid cell id in [ \a partBg, \a partEnd ) regarding the number of cells of \c this->getMesh() - * - * \ref cpp_mcfielddouble_subpart1 "Here a C++ example." + * \throw if there is presence of an invalid cell id in [ \a partBg, \a partEnd ) regarding the number of cells of \a this->getMesh(). * + * \ref cpp_mcfielddouble_subpart1 "Here a C++ example."
* \ref py_mcfielddouble_subpart1 "Here a Python example." * \sa ParaMEDMEM::MEDCouplingFieldDouble::buildSubPart(const DataArrayInt *) const, MEDCouplingFieldDouble::buildSubPartRange */ @@ -609,6 +766,11 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::buildSubPartRange(int begin, int return ret.retn(); } +/*! + * Returns a type of \ref MEDCouplingTemporalDisc "time discretization" of \a this field. + * \return ParaMEDMEM::TypeOfTimeDiscretization - an enum item describing the time + * discretization type. + */ TypeOfTimeDiscretization MEDCouplingFieldDouble::getTimeDiscretization() const { return _time_discr->getEnum(); @@ -641,6 +803,15 @@ MEDCouplingFieldDouble::~MEDCouplingFieldDouble() delete _time_discr; } +/*! + * Checks if \a this field is correctly defined, else an exception is thrown. + * \throw If the mesh is not set. + * \throw If the data array is not set. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If \a this->getTimeTolerance() < 0. + * \throw If the temporal discretization data is incorrect. + * \throw If mesh data does not correspond to field data. + */ void MEDCouplingFieldDouble::checkCoherency() const throw(INTERP_KERNEL::Exception) { if(!_mesh) @@ -652,7 +823,12 @@ void MEDCouplingFieldDouble::checkCoherency() const throw(INTERP_KERNEL::Excepti } /*! - * Returns the accumulation (the sum) of comId_th component of each tuples of \b default and \b only \b default array. + * Accumulate values of a given component of \a this field. + * \param [in] compId - the index of the component of interest. + * \return double - a sum value of *compId*-th component. + * \throw If the data array is not set. + * \throw If \a the condition ( 0 <= \a compId < \a this->getNumberOfComponents() ) is + * not respected. */ double MEDCouplingFieldDouble::accumulate(int compId) const { @@ -662,8 +838,11 @@ double MEDCouplingFieldDouble::accumulate(int compId) const } /*! - * Returns the accumulation (the sum) of all tuples of \b default and \b only default array. - * The res is expected to be of size getNumberOfComponents(). + * Accumulates values of each component of \a this array. + * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated + * by the caller, that is filled by this method with sum value for each + * component. + * \throw If the data array is not set. */ void MEDCouplingFieldDouble::accumulate(double *res) const { @@ -673,9 +852,12 @@ void MEDCouplingFieldDouble::accumulate(double *res) const } /*! - * This method returns the max value in \a this. \a this is expected to be a field with exactly \b one component. If not an exception will be thrown. - * To getMaxValue on vector field applyFunc is needed before. This method looks only on all arrays stored in 'this->_time_discr'. - * If no arrays exists, an exception will be thrown. + * Returns the maximal value within \a this scalar field. Values of all arrays stored + * in \a this->_time_discr are checked. + * \return double - the maximal value among all values of \a this field. + * \throw If \a this->getNumberOfComponents() != 1 + * \throw If the data array is not set. + * \throw If there is an empty data array in \a this field. */ double MEDCouplingFieldDouble::getMaxValue() const throw(INTERP_KERNEL::Exception) { @@ -698,11 +880,14 @@ double MEDCouplingFieldDouble::getMaxValue() const throw(INTERP_KERNEL::Exceptio } /*! - * This method is an extension of ParaMEDMEM::MEDCouplingFieldDouble::getMaxValue method because the returned - * value is the same but this method also returns to you a tupleIds object which the caller have the responsibility - * to deal with. The main difference is that the returned tupleIds is those corresponding the first set array. - * If you have more than one array set (in LINEAR_TIME instance for example) only the first not null array will be used - * to compute tupleIds. + * Returns the maximal value and all its locations within \a this scalar field. + * Only the first of available data arrays is checked. + * \param [out] tupleIds - a new instance of DataArrayInt containg indices of + * tuples holding the maximal value. The caller is to delete it using + * decrRef() as it is no more needed. + * \return double - the maximal value among all values of the first array of \a this filed. + * \throw If \a this->getNumberOfComponents() != 1. + * \throw If there is an empty data array in \a this field. */ double MEDCouplingFieldDouble::getMaxValue2(DataArrayInt*& tupleIds) const throw(INTERP_KERNEL::Exception) { @@ -731,9 +916,12 @@ double MEDCouplingFieldDouble::getMaxValue2(DataArrayInt*& tupleIds) const throw } /*! - * This method returns the min value in \a this. \a this is expected to be a field with exactly \b one component. If not an exception will be thrown. - * To getMinValue on vector field applyFunc is needed before. This method looks only on all arrays stored in 'this->_time_discr'. - * If no arrays exists, an exception will be thrown. + * Returns the minimal value within \a this scalar field. Values of all arrays stored + * in \a this->_time_discr are checked. + * \return double - the minimal value among all values of \a this field. + * \throw If \a this->getNumberOfComponents() != 1 + * \throw If the data array is not set. + * \throw If there is an empty data array in \a this field. */ double MEDCouplingFieldDouble::getMinValue() const throw(INTERP_KERNEL::Exception) { @@ -756,11 +944,14 @@ double MEDCouplingFieldDouble::getMinValue() const throw(INTERP_KERNEL::Exceptio } /*! - * This method is an extension of ParaMEDMEM::MEDCouplingFieldDouble::getMinValue method because the returned - * value is the same but this method also returns to you a tupleIds object which the caller have the responsibility - * to deal with. The main difference is that the returned tupleIds is those corresponding the first set array. - * If you have more than one array set (in LINEAR_TIME instance for example) only the first not null array will be used - * to compute tupleIds. + * Returns the minimal value and all its locations within \a this scalar field. + * Only the first of available data arrays is checked. + * \param [out] tupleIds - a new instance of DataArrayInt containg indices of + * tuples holding the minimal value. The caller is to delete it using + * decrRef() as it is no more needed. + * \return double - the minimal value among all values of the first array of \a this filed. + * \throw If \a this->getNumberOfComponents() != 1. + * \throw If there is an empty data array in \a this field. */ double MEDCouplingFieldDouble::getMinValue2(DataArrayInt*& tupleIds) const throw(INTERP_KERNEL::Exception) { @@ -789,9 +980,10 @@ double MEDCouplingFieldDouble::getMinValue2(DataArrayInt*& tupleIds) const throw } /*! - * This method returns the average value in \a this. \a this is expected to be a field with exactly \b one component. If not an exception will be thrown. - * To getAverageValue on vector field applyFunc is needed before. This method looks only \b default array \b and \b only \b default. - * If default array does not exist, an exception will be thrown. + * Returns the average value of \a this scalar field. + * \return double - the average value over all values of the data array. + * \throw If \a this->getNumberOfComponents() != 1 + * \throw If the data array is not set or it is empty. */ double MEDCouplingFieldDouble::getAverageValue() const throw(INTERP_KERNEL::Exception) { @@ -801,11 +993,11 @@ double MEDCouplingFieldDouble::getAverageValue() const throw(INTERP_KERNEL::Exce } /*! - * This method returns the euclidean norm of \a this. + * This method returns the euclidean norm of \a this field. * \f[ * \sqrt{\sum_{0 \leq i < nbOfEntity}val[i]*val[i]} * \f] - * If default array does not exist, an exception will be thrown. + * \throw If the data array is not set. */ double MEDCouplingFieldDouble::norm2() const throw(INTERP_KERNEL::Exception) { @@ -815,11 +1007,11 @@ double MEDCouplingFieldDouble::norm2() const throw(INTERP_KERNEL::Exception) } /*! - * This method returns the max norm of \a this. + * This method returns the max norm of \a this field. * \f[ * \max_{0 \leq i < nbOfEntity}{abs(val[i])} * \f] - * If default array does not exist, an exception will be thrown. + * \throw If the data array is not set. */ double MEDCouplingFieldDouble::normMax() const throw(INTERP_KERNEL::Exception) { @@ -829,14 +1021,16 @@ double MEDCouplingFieldDouble::normMax() const throw(INTERP_KERNEL::Exception) } /*! - * This method returns the average value in \a this weighted by ParaMEDMEM::MEDCouplingField::buildMeasureField. - * \a this is expected to be a field with exactly \b one component. If not an exception will be thrown. - * To getAverageValue on vector field applyFunc is needed before. This method looks only \b default array \b and \b only \b default. - * If default array does not exist, an exception will be thrown. - * - * \param [out] res the location where the result will be stored. \a res is expected to be a location with \c this->getNumberOfComponents() places available. - * \param [in] isWAbs specifies if abs is applied on measure on underlying mesh before performing computation. For a user already sure that all cells of its underlying mesh - * are all well oriented this parameter can be set to false to be 'faster'. By default this parameter is true. + * Computes sums of values of each component of \a this field wighted with + * values returned by buildMeasureField(). + * \param [out] res - pointer to an array of result sum values, of size at least \a + * this->getNumberOfComponents(), that is to be allocated by the caller. + * \param [in] isWAbs - if \c true (default), \c abs() is applied to the weighs computed by + * buildMeasureField() that makes this method slower. If a user is sure that all + * cells of the underlying mesh have correct orientation, he can put \a isWAbs == + * \c false that speeds up this method. + * \throw If the mesh is not set. + * \throw If the data array is not set. */ void MEDCouplingFieldDouble::getWeightedAverageValue(double *res, bool isWAbs) const throw(INTERP_KERNEL::Exception) { @@ -851,14 +1045,17 @@ void MEDCouplingFieldDouble::getWeightedAverageValue(double *res, bool isWAbs) c } /*! - * This method returns the average value in \a this weighted by ParaMEDMEM::MEDCouplingField::buildMeasureField. - * \a this is expected to be a field with exactly \b one component. If not an exception will be thrown. - * To getAverageValue on vector field applyFunc is needed before. This method looks only \b default array \b and \b only \b default. - * If default array does not exist, an exception will be thrown. - * - * \param [in] compId The component id that should be in [0, \c this->getNumberOfComponents() ). If not an INTERP_KERNEL::Exception will be thrown. - * \param [in] isWAbs specifies if abs is applied on measure on underlying mesh before performing computation. For a user already sure that all cells of its underlying mesh - * are all well oriented this parameter can be set to false to be 'faster'. By default this parameter is true in C++ not in python (overloading confusion). + * Computes a sum of values of a given component of \a this field wighted with + * values returned by buildMeasureField(). + * \param [in] compId - an index of the component of interest. + * \param [in] isWAbs - if \c true (default), \c abs() is applied to the weighs computed by + * buildMeasureField() that makes this method slower. If a user is sure that all + * cells of the underlying mesh have correct orientation, he can put \a isWAbs == + * \c false that speeds up this method. + * \throw If the mesh is not set. + * \throw If the data array is not set. + * \throw If \a compId is not valid. + A valid range is ( 0 <= \a compId < \a this->getNumberOfComponents() ). */ double MEDCouplingFieldDouble::getWeightedAverageValue(int compId, bool isWAbs) const throw(INTERP_KERNEL::Exception) { @@ -874,11 +1071,15 @@ double MEDCouplingFieldDouble::getWeightedAverageValue(int compId, bool isWAbs) } /*! - * Returns the normL1 of current field on compId component : + * Returns the \c normL1 of values of a given component of \a this field: * \f[ * \frac{\sum_{0 \leq i < nbOfEntity}|val[i]*Vol[i]|}{\sum_{0 \leq i < nbOfEntity}|Vol[i]|} * \f] - * If compId>=nbOfComponent an exception is thrown. + * \param [in] compId - an index of the component of interest. + * \throw If the mesh is not set. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If \a compId is not valid. + A valid range is ( 0 <= \a compId < \a this->getNumberOfComponents() ). */ double MEDCouplingFieldDouble::normL1(int compId) const throw(INTERP_KERNEL::Exception) { @@ -898,11 +1099,14 @@ double MEDCouplingFieldDouble::normL1(int compId) const throw(INTERP_KERNEL::Exc } /*! - * Returns the normL1 of current field on each components : + * Returns the \c normL1 of values of each component of \a this field: * \f[ * \frac{\sum_{0 \leq i < nbOfEntity}|val[i]*Vol[i]|}{\sum_{0 \leq i < nbOfEntity}|Vol[i]|} * \f] - * The res is expected to be of size getNumberOfComponents(). + * \param [out] res - pointer to an array of result values, of size at least \a + * this->getNumberOfComponents(), that is to be allocated by the caller. + * \throw If the mesh is not set. + * \throw If the spatial discretization of \a this field is NULL. */ void MEDCouplingFieldDouble::normL1(double *res) const throw(INTERP_KERNEL::Exception) { @@ -914,11 +1118,15 @@ void MEDCouplingFieldDouble::normL1(double *res) const throw(INTERP_KERNEL::Exce } /*! - * Returns the normL2 of current field on compId component : + * Returns the \c normL2 of values of a given component of \a this field: * \f[ * \sqrt{\frac{\sum_{0 \leq i < nbOfEntity}|val[i]^{2}*Vol[i]|}{\sum_{0 \leq i < nbOfEntity}|Vol[i]|}} * \f] - * If compId>=nbOfComponent an exception is thrown. + * \param [in] compId - an index of the component of interest. + * \throw If the mesh is not set. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If \a compId is not valid. + A valid range is ( 0 <= \a compId < \a this->getNumberOfComponents() ). */ double MEDCouplingFieldDouble::normL2(int compId) const throw(INTERP_KERNEL::Exception) { @@ -938,11 +1146,14 @@ double MEDCouplingFieldDouble::normL2(int compId) const throw(INTERP_KERNEL::Exc } /*! - * Returns the normL2 of current field on each components : + * Returns the \c normL2 of values of each component of \a this field: * \f[ * \sqrt{\frac{\sum_{0 \leq i < nbOfEntity}|val[i]^{2}*Vol[i]|}{\sum_{0 \leq i < nbOfEntity}|Vol[i]|}} * \f] - * The res is expected to be of size getNumberOfComponents(). + * \param [out] res - pointer to an array of result values, of size at least \a + * this->getNumberOfComponents(), that is to be allocated by the caller. + * \throw If the mesh is not set. + * \throw If the spatial discretization of \a this field is NULL. */ void MEDCouplingFieldDouble::normL2(double *res) const throw(INTERP_KERNEL::Exception) { @@ -954,9 +1165,18 @@ void MEDCouplingFieldDouble::normL2(double *res) const throw(INTERP_KERNEL::Exce } /*! - * Returns the accumulation (the sum) of comId_th component of each tuples weigthed by the field - * returns by getWeightingField relative of the _type of field of default array. + * Computes a sum of values of a given component of \a this field multiplied by + * values returned by buildMeasureField(). * This method is useful to check the conservativity of interpolation method. + * \param [in] compId - an index of the component of interest. + * \param [in] isWAbs - if \c true (default), \c abs() is applied to the weighs computed by + * buildMeasureField() that makes this method slower. If a user is sure that all + * cells of the underlying mesh have correct orientation, he can put \a isWAbs == + * \c false that speeds up this method. + * \throw If the mesh is not set. + * \throw If the data array is not set. + * \throw If \a compId is not valid. + A valid range is ( 0 <= \a compId < \a this->getNumberOfComponents() ). */ double MEDCouplingFieldDouble::integral(int compId, bool isWAbs) const throw(INTERP_KERNEL::Exception) { @@ -976,9 +1196,18 @@ double MEDCouplingFieldDouble::integral(int compId, bool isWAbs) const throw(INT } /*! - * Returns the accumulation (the sum) of each tuples weigthed by the field - * returns by getWeightingField relative of the _type of field of default array. + * Computes a sum of values of each component of \a this field multiplied by + * values returned by buildMeasureField(). * This method is useful to check the conservativity of interpolation method. + * \param [in] isWAbs - if \c true (default), \c abs() is applied to the weighs computed by + * buildMeasureField() that makes this method slower. If a user is sure that all + * cells of the underlying mesh have correct orientation, he can put \a isWAbs == + * \c false that speeds up this method. + * \param [out] res - pointer to an array of result sum values, of size at least \a + * this->getNumberOfComponents(), that is to be allocated by the caller. + * \throw If the mesh is not set. + * \throw If the data array is not set. + * \throw If the spatial discretization of \a this field is NULL. */ void MEDCouplingFieldDouble::integral(bool isWAbs, double *res) const throw(INTERP_KERNEL::Exception) { @@ -990,9 +1219,22 @@ void MEDCouplingFieldDouble::integral(bool isWAbs, double *res) const throw(INTE } /*! - * This method is reserved for field lying on structured mesh spatial support. It returns the value of cell localized by (i,j,k) - * If spatial support is not structured mesh an exception will be thrown. - * @param res out array expected to be equal to size getNumberOfComponents() + * Returns a value at a given cell of a structured mesh. The cell is specified by its + * (i,j,k) index. + * \param [in] i - a index of node coordinates array along X axis. The cell is + * located between the i-th and ( i + 1 )-th nodes along X axis. + * \param [in] j - a index of node coordinates array along Y axis. The cell is + * located between the j-th and ( j + 1 )-th nodes along Y axis. + * \param [in] k - a index of node coordinates array along Z axis. The cell is + * located between the k-th and ( k + 1 )-th nodes along Z axis. + * \param [out] res - pointer to an array returning a feild value, of size at least + * \a this->getNumberOfComponents(), that is to be allocated by the caller. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. + * \throw If the mesh is not a structured one. + * + * \ref cpp_mcfielddouble_getValueOnPos "Here is a C++ example".
+ * \ref py_mcfielddouble_getValueOnPos "Here is a Python example". */ void MEDCouplingFieldDouble::getValueOnPos(int i, int j, int k, double *res) const throw(INTERP_KERNEL::Exception) { @@ -1005,8 +1247,16 @@ void MEDCouplingFieldDouble::getValueOnPos(int i, int j, int k, double *res) con } /*! - * Returns value of \a this on default time of point 'spaceLoc' using spatial discretization. - * If 'point' is outside the spatial discretization of this an exception will be thrown. + * Returns a value of \a this at a given point using spatial discretization. + * \param [in] spaceLoc - the point of interest. + * \param [out] res - pointer to an array returning a feild value, of size at least + * \a this->getNumberOfComponents(), that is to be allocated by the caller. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. + * \throw If \a spaceLoc is out of the spatial discretization. + * + * \ref cpp_mcfielddouble_getValueOn "Here is a C++ example".
+ * \ref py_mcfielddouble_getValueOn "Here is a Python example". */ void MEDCouplingFieldDouble::getValueOn(const double *spaceLoc, double *res) const throw(INTERP_KERNEL::Exception) { @@ -1019,7 +1269,20 @@ void MEDCouplingFieldDouble::getValueOn(const double *spaceLoc, double *res) con } /*! - * Returns a newly allocated array with 'nbOfPoints' tuples and nb of components equal to 'this->getNumberOfComponents()'. + * Returns values of \a this at given points using spatial discretization. + * \param [in] spaceLoc - coordinates of points of interest in full-interlace + * mode. This array is to be of size ( \a nbOfPoints * \a this->getNumberOfComponents() ). + * \param [in] nbOfPoints - number of points of interest. + * \return DataArrayDouble * - a new instance of DataArrayDouble holding field + * values relating to the input points. This array is of size \a nbOfPoints + * tuples per \a this->getNumberOfComponents() components. The caller is to + * delete this array using decrRef() as it is no more needed. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. + * \throw If any point in \a spaceLoc is out of the spatial discretization. + * + * \ref cpp_mcfielddouble_getValueOnMulti "Here is a C++ example".
+ * \ref py_mcfielddouble_getValueOnMulti "Here is a Python example". */ DataArrayDouble *MEDCouplingFieldDouble::getValueOnMulti(const double *spaceLoc, int nbOfPoints) const throw(INTERP_KERNEL::Exception) { @@ -1032,9 +1295,19 @@ DataArrayDouble *MEDCouplingFieldDouble::getValueOnMulti(const double *spaceLoc, } /*! - * Returns value of \a this on time 'time' of point 'spaceLoc' using spatial discretization. - * If 'time' is not covered by this->_time_discr an exception will be thrown. - * If 'point' is outside the spatial discretization of this an exception will be thrown. + * Returns a value of \a this field at a given point at a given time using spatial discretization. + * If the time is not covered by \a this->_time_discr, an exception is thrown. + * \param [in] spaceLoc - the point of interest. + * \param [in] time - the time of interest. + * \param [out] res - pointer to an array returning a feild value, of size at least + * \a this->getNumberOfComponents(), that is to be allocated by the caller. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. + * \throw If \a spaceLoc is out of the spatial discretization. + * \throw If \a time is not covered by \a this->_time_discr. + * + * \ref cpp_mcfielddouble_getValueOn_time "Here is a C++ example".
+ * \ref py_mcfielddouble_getValueOn_time "Here is a Python example". */ void MEDCouplingFieldDouble::getValueOn(const double *spaceLoc, double time, double *res) const throw(INTERP_KERNEL::Exception) { @@ -1054,7 +1327,12 @@ void MEDCouplingFieldDouble::getValueOn(const double *spaceLoc, double time, dou } /*! - * Applies a*x+b on 'compoId'th component of each cell. + * Apply a liner function to a given component of \a this field, so that + * a component value (x) becomes \f$ a * x + b \f$. + * \param [in] a - the first coefficient of the function. + * \param [in] b - the second coefficient of the function. + * \param [in] compoId - the index of component to modify. + * \throw If the data array(s) is(are) not set. */ void MEDCouplingFieldDouble::applyLin(double a, double b, int compoId) { @@ -1078,10 +1356,16 @@ MEDCouplingFieldDouble &MEDCouplingFieldDouble::operator=(double value) throw(IN } /*! - * This method is very similar to this one MEDCouplingMesh::fillFromAnalytic. - * See MEDCouplingMesh::fillFromAnalytic method doc to have more details. - * The main difference is that the field as been started to be constructed here. - * An exception is thrown if no underlying mesh is set before the call of this method. + * Creates data array(s) of \a this field by using a C function for value generation. + * \param [in] nbOfComp - the number of components for \a this field to have. + * \param [in] func - the function used to compute values of \a this field. + * This function is to compute a field value basing on coordinates of value + * location point. + * \throw If the mesh is not set. + * \throw If \a func returns \c false. + * \throw If the spatial discretization of \a this field is NULL. + * + * \ref cpp_mcfielddouble_fillFromAnalytic_c_func "Here is a C++ example". */ void MEDCouplingFieldDouble::fillFromAnalytic(int nbOfComp, FunctionToEvaluate func) throw(INTERP_KERNEL::Exception) { @@ -1094,10 +1378,39 @@ void MEDCouplingFieldDouble::fillFromAnalytic(int nbOfComp, FunctionToEvaluate f } /*! - * This method is very similar to this one MEDCouplingMesh::fillFromAnalytic. - * See MEDCouplingMesh::fillFromAnalytic method doc to have more details. - * The main difference is that the field as been started to be constructed here. - * An exception is thrown if no underlying mesh is set before the call of this method. + * Creates data array(s) of \a this field by using a function for value generation.
+ * The function is applied to coordinates of value location points. For example, if + * \a this field is on cells, the function is applied to cell barycenters. + * For more info on supported expressions that can be used in the function, see \ref + * MEDCouplingArrayApplyFuncExpr.
+ * The function can include arbitrary named variables + * (e.g. "x","y" or "va44") to refer to components of point coordinates. Names of + * variables are sorted in \b alphabetical \b order to associate a variable name with a + * component. For example, in the expression "2*x+z", "x" stands for the component #0 + * and "z" stands for the component #1 (\b not #2)!
+ * In a general case, a value resulting from the function evaluation is assigned to all + * components of a field value. But there is a possibility to have its own expression for + * each component within one function. For this purpose, there are predefined variable + * names (IVec, JVec, KVec, LVec etc) each dedicated to a certain component (IVec, to + * the component #0 etc). A factor of such a variable is added to the + * corresponding component only.
+ * For example, \a nbOfComp == 4, coordinates of a 3D point are (1.,3.,7.), then + * - "2*x + z" produces (5.,5.,5.,5.) + * - "2*x + 0*y + z" produces (9.,9.,9.,9.) + * - "2*x*IVec + (x+z)*LVec" produces (2.,0.,0.,4.) + * - "2*y*IVec + z*KVec + x" produces (7.,1.,1.,4.) + * + * \param [in] nbOfComp - the number of components for \a this field to have. + * \param [in] func - the function used to compute values of \a this field. + * This function is used to compute a field value basing on coordinates of value + * location point. For example, if \a this field is on cells, the function + * is applied to cell barycenters. + * \throw If the mesh is not set. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If computing \a func fails. + * + * \ref cpp_mcfielddouble_fillFromAnalytic "Here is a C++ example".
+ * \ref py_mcfielddouble_fillFromAnalytic "Here is a Python example". */ void MEDCouplingFieldDouble::fillFromAnalytic(int nbOfComp, const char *func) throw(INTERP_KERNEL::Exception) { @@ -1110,10 +1423,41 @@ void MEDCouplingFieldDouble::fillFromAnalytic(int nbOfComp, const char *func) th } /*! - * This method is very similar to this one MEDCouplingMesh::fillFromAnalytic2. - * See MEDCouplingMesh::fillFromAnalytic method doc to have more details. - * The main difference is that the field as been started to be constructed here. - * An exception is throw if no underlying mesh is set before the call of this method. + * Creates data array(s) of \a this field by using a function for value generation.
+ * The function is applied to coordinates of value location points. For example, if + * \a this field is on cells, the function is applied to cell barycenters.
+ * This method differs from + * \ref ParaMEDMEM::MEDCouplingFieldDouble::fillFromAnalytic(int nbOfComp, const char *func) "fillFromAnalytic()" + * by the way how variable + * names, used in the function, are associated with components of coordinates of field + * location points; here, a variable name corresponding to a component is retrieved from + * a corresponding node coordinates array (where it is set via + * DataArrayDouble::setInfoOnComponent()).
+ * For more info on supported expressions that can be used in the function, see \ref + * MEDCouplingArrayApplyFuncExpr.
+ * In a general case, a value resulting from the function evaluation is assigned to all + * components of a field value. But there is a possibility to have its own expression for + * each component within one function. For this purpose, there are predefined variable + * names (IVec, JVec, KVec, LVec etc) each dedicated to a certain component (IVec, to + * the component #0 etc). A factor of such a variable is added to the + * corresponding component only.
+ * For example, \a nbOfComp == 4, names of spatial components are "x", "y" and "z", + * coordinates of a 3D point are (1.,3.,7.), then + * - "2*x + z" produces (9.,9.,9.,9.) + * - "2*x*IVec + (x+z)*LVec" produces (2.,0.,0.,8.) + * - "2*y*IVec + z*KVec + x" produces (7.,1.,1.,8.) + * + * \param [in] nbOfComp - the number of components for \a this field to have. + * \param [in] func - the function used to compute values of \a this field. + * This function is used to compute a field value basing on coordinates of value + * location point. For example, if \a this field is on cells, the function + * is applied to cell barycenters. + * \throw If the mesh is not set. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If computing \a func fails. + * + * \ref cpp_mcfielddouble_fillFromAnalytic2 "Here is a C++ example".
+ * \ref py_mcfielddouble_fillFromAnalytic2 "Here is a Python example". */ void MEDCouplingFieldDouble::fillFromAnalytic2(int nbOfComp, const char *func) throw(INTERP_KERNEL::Exception) { @@ -1126,10 +1470,41 @@ void MEDCouplingFieldDouble::fillFromAnalytic2(int nbOfComp, const char *func) t } /*! - * This method is very similar to this one MEDCouplingMesh::fillFromAnalytic3. - * See MEDCouplingMesh::fillFromAnalytic method doc to have more details. - * The main difference is that the field as been started to be constructed here. - * An exception is thrown if no underlying mesh is set before the call of this method. + * Creates data array(s) of \a this field by using a function for value generation.
+ * The function is applied to coordinates of value location points. For example, if + * \a this field is on cells, the function is applied to cell barycenters.
+ * This method differs from + * \ref ParaMEDMEM::MEDCouplingFieldDouble::fillFromAnalytic(int nbOfComp, const char *func) "fillFromAnalytic()" + * by the way how variable + * names, used in the function, are associated with components of coordinates of field + * location points; here, a component index of a variable is defined by a + * rank of the variable within the input array \a varsOrder.
+ * For more info on supported expressions that can be used in the function, see \ref + * MEDCouplingArrayApplyFuncExpr. + * In a general case, a value resulting from the function evaluation is assigned to all + * components of a field value. But there is a possibility to have its own expression for + * each component within one function. For this purpose, there are predefined variable + * names (IVec, JVec, KVec, LVec etc) each dedicated to a certain component (IVec, to + * the component #0 etc). A factor of such a variable is added to the + * corresponding component only.
+ * For example, \a nbOfComp == 4, names of + * spatial components are given in \a varsOrder: ["x", "y","z"], coordinates of a + * 3D point are (1.,3.,7.), then + * - "2*x + z" produces (9.,9.,9.,9.) + * - "2*x*IVec + (x+z)*LVec" produces (2.,0.,0.,8.) + * - "2*y*IVec + z*KVec + x" produces (7.,1.,1.,8.) + * + * \param [in] nbOfComp - the number of components for \a this field to have. + * \param [in] func - the function used to compute values of \a this field. + * This function is used to compute a field value basing on coordinates of value + * location point. For example, if \a this field is on cells, the function + * is applied to cell barycenters. + * \throw If the mesh is not set. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If computing \a func fails. + * + * \ref cpp_mcfielddouble_fillFromAnalytic3 "Here is a C++ example".
+ * \ref py_mcfielddouble_fillFromAnalytic3 "Here is a Python example". */ void MEDCouplingFieldDouble::fillFromAnalytic3(int nbOfComp, const std::vector& varsOrder, const char *func) throw(INTERP_KERNEL::Exception) { @@ -1142,8 +1517,14 @@ void MEDCouplingFieldDouble::fillFromAnalytic3(int nbOfComp, const std::vector + * This method is a specialization of other overloaded methods. When \a nbOfComp == 1 + * this method is equivalent to ParaMEDMEM::MEDCouplingFieldDouble::operator=(). + * \param [in] nbOfComp - the number of components for \a this field to have. + * \param [in] val - the value to assign to every atomic value of \a this field. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the mesh is not set. + * + * \ref cpp_mcfielddouble_applyFunc_val "Here is a C++ example".
+ * \ref py_mcfielddouble_applyFunc_val "Here is a Python example". */ void MEDCouplingFieldDouble::applyFunc(int nbOfComp, double val) { @@ -1165,18 +1554,72 @@ void MEDCouplingFieldDouble::applyFunc(int nbOfComp, double val) } /*! - * Applyies the function specified by the string repr 'func' on each tuples on all arrays contained in _time_discr. - * If '*func' fails in evaluation during one evaluation an exception will be thrown. - * The field will contain 'nbOfComp' components after the call. + * Modifies values of \a this field by applying a function to each tuple of all + * data arrays. + * For more info on supported expressions that can be used in the function, see \ref + * MEDCouplingArrayApplyFuncExpr.
+ * The function can include arbitrary named variables + * (e.g. "x","y" or "va44") to refer to components of a field value. Names of + * variables are sorted in \b alphabetical \b order to associate a variable name with a + * component. For example, in the expression "2*x+z", "x" stands for the component #0 + * and "z" stands for the component #1 (\b not #2)!
+ * In a general case, a value resulting from the function evaluation is assigned to all + * components of a field value. But there is a possibility to have its own expression for + * each component within one function. For this purpose, there are predefined variable + * names (IVec, JVec, KVec, LVec etc) each dedicated to a certain component (IVec, to + * the component #0 etc). A factor of such a variable is added to the + * corresponding component only.
+ * For example, \a nbOfComp == 4, components of a field value are (1.,3.,7.), then + * - "2*x + z" produces (5.,5.,5.,5.) + * - "2*x + 0*y + z" produces (9.,9.,9.,9.) + * - "2*x*IVec + (x+z)*LVec" produces (2.,0.,0.,4.) + * - "2*y*IVec + z*KVec + x" produces (7.,1.,1.,4.) + * + * \param [in] nbOfComp - the number of components for \a this field to have. + * \param [in] func - the function used to compute values of \a this field. + * This function is to compute a field value basing on a current field value. + * \throw If computing \a func fails. + * + * \ref cpp_mcfielddouble_applyFunc "Here is a C++ example".
+ * \ref py_mcfielddouble_applyFunc "Here is a Python example". */ void MEDCouplingFieldDouble::applyFunc(int nbOfComp, const char *func) throw(INTERP_KERNEL::Exception) { _time_discr->applyFunc(nbOfComp,func); } + /*! - * This method is equivalent to MEDCouplingFieldDouble::applyFunc, except that here components info are used to determine variables position in 'func'. - * If there is vars detected in 'func' that is not in an info on components an exception will be thrown. + * Modifies values of \a this field by applying a function to each tuple of all + * data arrays. + * For more info on supported expressions that can be used in the function, see \ref + * MEDCouplingArrayApplyFuncExpr.
+ * This method differs from + * \ref ParaMEDMEM::MEDCouplingFieldDouble::applyFunc(int nbOfComp, const char *func) "applyFunc()" + * by the way how variable + * names, used in the function, are associated with components of field values; + * here, a variable name corresponding to a component is retrieved from + * component information of an array (where it is set via + * DataArrayDouble::setInfoOnComponent()).
+ * In a general case, a value resulting from the function evaluation is assigned to all + * components of a field value. But there is a possibility to have its own expression for + * each component within one function. For this purpose, there are predefined variable + * names (IVec, JVec, KVec, LVec etc) each dedicated to a certain component (IVec, to + * the component #0 etc). A factor of such a variable is added to the + * corresponding component only.
+ * For example, \a nbOfComp == 4, components of a field value are (1.,3.,7.), then + * - "2*x + z" produces (5.,5.,5.,5.) + * - "2*x + 0*y + z" produces (9.,9.,9.,9.) + * - "2*x*IVec + (x+z)*LVec" produces (2.,0.,0.,4.) + * - "2*y*IVec + z*KVec + x" produces (7.,1.,1.,4.) + * + * \param [in] nbOfComp - the number of components for \a this field to have. + * \param [in] func - the function used to compute values of \a this field. + * This function is to compute a new field value basing on a current field value. + * \throw If computing \a func fails. + * + * \ref cpp_mcfielddouble_applyFunc2 "Here is a C++ example".
+ * \ref py_mcfielddouble_applyFunc2 "Here is a Python example". */ void MEDCouplingFieldDouble::applyFunc2(int nbOfComp, const char *func) throw(INTERP_KERNEL::Exception) { @@ -1184,8 +1627,36 @@ void MEDCouplingFieldDouble::applyFunc2(int nbOfComp, const char *func) throw(IN } /*! - * This method is equivalent to MEDCouplingFieldDouble::applyFunc, except that here 'varsOrder' is used to determine variables position in 'func'. - * If there is vars detected in 'func' that is not in 'varsOrder' an exception will be thrown. + * Modifies values of \a this field by applying a function to each tuple of all + * data arrays. + * This method differs from + * \ref ParaMEDMEM::MEDCouplingFieldDouble::applyFunc(int nbOfComp, const char *func) "applyFunc()" + * by the way how variable + * names, used in the function, are associated with components of field values; + * here, a component index of a variable is defined by a + * rank of the variable within the input array \a varsOrder.
+ * For more info on supported expressions that can be used in the function, see \ref + * MEDCouplingArrayApplyFuncExpr. + * In a general case, a value resulting from the function evaluation is assigned to all + * components of a field value. But there is a possibility to have its own expression for + * each component within one function. For this purpose, there are predefined variable + * names (IVec, JVec, KVec, LVec etc) each dedicated to a certain component (IVec, to + * the component #0 etc). A factor of such a variable is added to the + * corresponding component only.
+ * For example, \a nbOfComp == 4, names of + * components are given in \a varsOrder: ["x", "y","z"], components of a + * 3D vector are (1.,3.,7.), then + * - "2*x + z" produces (9.,9.,9.,9.) + * - "2*x*IVec + (x+z)*LVec" produces (2.,0.,0.,8.) + * - "2*y*IVec + z*KVec + x" produces (7.,1.,1.,8.) + * + * \param [in] nbOfComp - the number of components for \a this field to have. + * \param [in] func - the function used to compute values of \a this field. + * This function is to compute a new field value basing on a current field value. + * \throw If computing \a func fails. + * + * \ref cpp_mcfielddouble_applyFunc3 "Here is a C++ example".
+ * \ref py_mcfielddouble_applyFunc3 "Here is a Python example". */ void MEDCouplingFieldDouble::applyFunc3(int nbOfComp, const std::vector& varsOrder, const char *func) throw(INTERP_KERNEL::Exception) { @@ -1193,9 +1664,29 @@ void MEDCouplingFieldDouble::applyFunc3(int nbOfComp, const std::vector + * The function can include **only one** arbitrary named variable + * (e.g. "x","y" or "va44") to refer to a field atomic value.
+ * In a general case, a value resulting from the function evaluation is assigned to + * a single field value. But there is a possibility to have its own expression for + * each component within one function. For this purpose, there are predefined variable + * names (IVec, JVec, KVec, LVec etc) each dedicated to a certain component (IVec, to + * the component #0 etc). A factor of such a variable is added to the + * corresponding component only.
+ * For example, components of a field value are (1.,3.,7.), then + * - "2*x - 1" produces (1.,5.,13.) + * - "2*x*IVec + (x+3)*KVec" produces (2.,0.,10.) + * - "2*x*IVec + (x+3)*KVec + 1" produces (3.,1.,11.) + * + * \param [in] func - the function used to compute values of \a this field. + * This function is to compute a field value basing on a current field value. + * \throw If computing \a func fails. + * + * \ref cpp_mcfielddouble_applyFunc_same_nb_comp "Here is a C++ example".
+ * \ref py_mcfielddouble_applyFunc_same_nb_comp "Here is a Python example". */ void MEDCouplingFieldDouble::applyFunc(const char *func) throw(INTERP_KERNEL::Exception) { @@ -1223,9 +1714,10 @@ void MEDCouplingFieldDouble::applyFuncFast64(const char *func) throw(INTERP_KERN } /*! - * This method makes the assumption that the default array has been set before. - * If not an exception will be sent. - * If default array set, the number of components will be sent. + * Returns number of components in the data array. For more info on the data arrays, + * see \ref MEDCouplingArrayPage. + * \return int - the number of components in the data array. + * \throw If the data array is not set. */ int MEDCouplingFieldDouble::getNumberOfComponents() const throw(INTERP_KERNEL::Exception) { @@ -1235,11 +1727,22 @@ int MEDCouplingFieldDouble::getNumberOfComponents() const throw(INTERP_KERNEL::E } /*! - * This method makes the assumption that _mesh has be set before the call of this method and description of gauss - * localizations in case of Gauss field. If not an exception will sent. - * \b Contrary to MEDCouplingFieldDouble::getNumberOfComponents and MEDCouplingFieldDouble::getNumberOfValues is - * \b not aware of the presence of the default array. - * \b WARNING \b no coherency check is done here. MEDCouplingFieldDouble::checkCoherency method should be called to check that ! + * Returns number of tuples in \a this field, that depends on + * - the number of entities in the underlying mesh + * - \ref MEDCouplingSpatialDisc "spatial discretization" of \a this field (e.g. number + * of Gauss points if \a this->getTypeOfField() == + * \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT"). + * + * The returned value does **not depend** on the number of tuples in the data array + * (which has to be equal to the returned value), \b contrary to + * getNumberOfComponents() and getNumberOfValues() that retrieve information from the + * data array. + * \warning No checkCoherency() is done here. + * For more info on the data arrays, see \ref MEDCouplingArrayPage. + * \return int - the number of tuples. + * \throw If the mesh is not set. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the spatial discretization is not fully defined. */ int MEDCouplingFieldDouble::getNumberOfTuples() const throw(INTERP_KERNEL::Exception) { @@ -1251,9 +1754,11 @@ int MEDCouplingFieldDouble::getNumberOfTuples() const throw(INTERP_KERNEL::Excep } /*! - * This method makes the assumption that the default array has been set before. - * If not an exception will be sent. - * If default array set, the number of values present in the default array will be sent. + * Returns number of atomic double values in the data array of \a this field. + * For more info on the data arrays, see \ref MEDCouplingArrayPage. + * \return int - (number of tuples) * (number of components) of the + * data array. + * \throw If the data array is not set. */ int MEDCouplingFieldDouble::getNumberOfValues() const throw(INTERP_KERNEL::Exception) { @@ -1262,6 +1767,10 @@ int MEDCouplingFieldDouble::getNumberOfValues() const throw(INTERP_KERNEL::Excep return getArray()->getNbOfElems(); } +/*! + * Sets own modification time by the most recently modified element of data (the mesh, + * the data array etc). For more info, see \ref MEDCouplingTimeLabelPage. + */ void MEDCouplingFieldDouble::updateTime() const { MEDCouplingField::updateTime(); @@ -1276,6 +1785,10 @@ std::size_t MEDCouplingFieldDouble::getHeapMemorySize() const return MEDCouplingField::getHeapMemorySize()+ret; } +/*! + * Sets \ref NatureOfField. + * \param [in] nat - an item of enum ParaMEDMEM::NatureOfField. + */ void MEDCouplingFieldDouble::setNature(NatureOfField nat) throw(INTERP_KERNEL::Exception) { MEDCouplingField::setNature(nat); @@ -1298,6 +1811,21 @@ void MEDCouplingFieldDouble::synchronizeTimeWithMesh() throw(INTERP_KERNEL::Exce setTimeUnit(timeUnit.c_str()); } +/*! + * Returns a value of \a this field of type either + * \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT" or + * \ref ParaMEDMEM::ON_GAUSS_NE "ON_GAUSS_NE". + * \param [in] cellId - an id of cell of interest. + * \param [in] nodeIdInCell - a node index within the cell. + * \param [in] compoId - an index of component. + * \return double - the field value corresponding to the specified parameters. + * \throw If the data array is not set. + * \throw If the mesh is not set. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If \a this field if of type other than + * \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT" or + * \ref ParaMEDMEM::ON_GAUSS_NE "ON_GAUSS_NE". + */ double MEDCouplingFieldDouble::getIJK(int cellId, int nodeIdInCell, int compoId) const { if(!((const MEDCouplingFieldDiscretization *)_type)) @@ -1305,16 +1833,40 @@ double MEDCouplingFieldDouble::getIJK(int cellId, int nodeIdInCell, int compoId) return _type->getIJK(_mesh,getArray(),cellId,nodeIdInCell,compoId); } +/*! + * Sets the data array. + * \param [in] array - the data array holding values of \a this field. It's size + * should correspond to the mesh and + * \ref MEDCouplingSpatialDisc "spatial discretization" of \a this field + * (see getNumberOfTuples()), but this size is not checked here. + */ void MEDCouplingFieldDouble::setArray(DataArrayDouble *array) { _time_discr->setArray(array,this); } +/*! + * Sets the data array holding values corresponding to an end of a time interval + * for which \a this field is defined. + * \param [in] array - the data array holding values of \a this field. It's size + * should correspond to the mesh and + * \ref MEDCouplingSpatialDisc "spatial discretization" of \a this field + * (see getNumberOfTuples()), but this size is not checked here. + */ void MEDCouplingFieldDouble::setEndArray(DataArrayDouble *array) { _time_discr->setEndArray(array,this); } +/*! + * Sets all data arrays needed to define the field values. + * \param [in] arrs - a vector of DataArrayDouble's holding values of \a this + * field. Size of each array should correspond to the mesh and + * \ref MEDCouplingSpatialDisc "spatial discretization" of \a this field + * (see getNumberOfTuples()), but this size is not checked here. + * \throw If number of arrays in \a arrs does not correspond to type of + * \ref MEDCouplingTemporalDisc "temporal discretization" of \a this field. + */ void MEDCouplingFieldDouble::setArrays(const std::vector& arrs) throw(INTERP_KERNEL::Exception) { _time_discr->setArrays(arrs,this); @@ -1421,9 +1973,27 @@ void MEDCouplingFieldDouble::serialize(DataArrayInt *&dataInt, std::vector_mesh is not defined or other an exeption will be throw. + * Tries to set an \a other mesh as the support of \a this field. An attempt fails, if + * a current and the \a other meshes are different with use of specified equality + * criteria, and then an exception is thrown. + * \param [in] other - the mesh to use as the field support if this mesh can be + * considered equal to the current mesh. + * \param [in] levOfCheck - defines equality criteria used for mesh comparison. For + * it's meaning explanation, see MEDCouplingMesh::checkGeoEquivalWith() which + * is used for mesh comparison. + * \param [in] precOnMesh - a precision used to compare nodes of the two meshes. + * It is used as \a prec parameter of MEDCouplingMesh::checkGeoEquivalWith(). + * \param [in] eps - a precision used at node renumbering (if needed) to compare field + * values at merged nodes. If the values differ more than \a eps, an + * exception is thrown. + * \throw If the mesh is not set. + * \throw If \a other == NULL. + * \throw If any of the meshes is not well defined. + * \throw If the two meshes do not match. + * \throw If field values at merged nodes (if any) deffer more than \a eps. + * + * \ref cpp_mcfielddouble_changeUnderlyingMesh "Here is a C++ example".
+ * \ref py_mcfielddouble_changeUnderlyingMesh "Here is a Python example". */ void MEDCouplingFieldDouble::changeUnderlyingMesh(const MEDCouplingMesh *other, int levOfCheck, double precOnMesh, double eps) throw(INTERP_KERNEL::Exception) { @@ -1440,12 +2010,37 @@ void MEDCouplingFieldDouble::changeUnderlyingMesh(const MEDCouplingMesh *other, } /*! - * This method is an extension of MEDCouplingFieldDouble::operator-=. It allows a user to operate a difference of 2 fields (\a this and 'f') even if they do not share same meshes. - * No interpolation will be done here only an analyze of two underlying mesh will be done to see if the meshes are geometrically equivalent. If yes, the eventual renumbering will be done and operator-= applyed after. - * This method requires that 'f' and \a this are coherent (check coherency) and that 'f' and \a this would be coherent for a merge. - * Semantic of 'levOfCheck' is explained in MEDCouplingMesh::checkGeoEquivalWith method. - * \param [in] precOnMesh precision for the mesh comparison between \c this->getMesh() and \c f->getMesh() - * \param [in] eps the precision on values that can appear in case of + * Subtracts another field from \a this one in case when the two fields have different + * supporting meshes. The subtraction is performed provided that the tho meshes can be + * considered equal with use of specified equality criteria, else an exception is thrown. + * If the meshes match, the mesh of \a f is set to \a this field (\a this is permuted if + * necessary) and field values are subtracted. No interpolation is done here, only an + * analysis of two underlying mesh is done to see if the meshes are geometrically + * equivalent.
+ * The job of this method consists in calling + * \a this->changeUnderlyingMesh() with \a f->getMesh() as the first parameter, and then + * \a this -= \a f.
+ * This method requires that \a f and \a this are coherent (checkCoherency()) and that \a f + * and \a this are coherent for a merge.
+ * "DM" in the method name stands for "different meshes". + * \param [in] f - the field to subtract from this. + * \param [in] levOfCheck - defines equality criteria used for mesh comparison. For + * it's meaning explanation, see MEDCouplingMesh::checkGeoEquivalWith() which + * is used for mesh comparison. + * \param [in] precOnMesh - a precision used to compare nodes of the two meshes. + * It is used as \a prec parameter of MEDCouplingMesh::checkGeoEquivalWith(). + * \param [in] eps - a precision used at node renumbering (if needed) to compare field + * values at merged nodes. If the values differ more than \a eps, an + * exception is thrown. + * \throw If \a f == NULL. + * \throw If any of the meshes is not set or is not well defined. + * \throw If the two meshes do not match. + * \throw If the two fields are not coherent for merge. + * \throw If field values at merged nodes (if any) deffer more than \a eps. + * + * \ref cpp_mcfielddouble_substractInPlaceDM "Here is a C++ example".
+ * \ref py_mcfielddouble_substractInPlaceDM "Here is a Python example". + * \sa changeUnderlyingMesh(). */ void MEDCouplingFieldDouble::substractInPlaceDM(const MEDCouplingFieldDouble *f, int levOfCheck, double precOnMesh, double eps) throw(INTERP_KERNEL::Exception) { @@ -1460,9 +2055,19 @@ void MEDCouplingFieldDouble::substractInPlaceDM(const MEDCouplingFieldDouble *f, } /*! - * Merge nodes of underlying mesh. In case of some node will be merged the underlying mesh instance will change. - * The first 'eps' stands for geometric approximation. The second 'epsOnVals' is for epsilon on values in case of node merging. - * If 2 nodes distant from less than 'eps' and with value different with more than 'epsOnVals' an exception will be thrown. + * Merges coincident nodes of the underlying mesh. If some nodes are coincident, the + * underlying mesh is replaced by a new mesh instance where the coincident nodes are merged. + * \param [in] eps - a precision used to compare nodes of the two meshes. + * \param [in] epsOnVals - a precision used to compare field + * values at merged nodes. If the values differ more than \a epsOnVals, an + * exception is thrown. + * \return bool - \c true if some nodes have been merged and hence \a this field lies + * on another mesh. + * \throw If the mesh is of type not inheriting from MEDCouplingPointSet. + * \throw If the mesh is not well defined. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the data array is not set. + * \throw If field values at merged nodes (if any) deffer more than \a epsOnVals. */ bool MEDCouplingFieldDouble::mergeNodes(double eps, double epsOnVals) throw(INTERP_KERNEL::Exception) { @@ -1487,9 +2092,21 @@ bool MEDCouplingFieldDouble::mergeNodes(double eps, double epsOnVals) throw(INTE } /*! - * Merge nodes with (barycenter computation) of underlying mesh. In case of some node will be merged the underlying mesh instance will change. - * The first 'eps' stands for geometric approximation. The second 'epsOnVals' is for epsilon on values in case of node merging. - * If 2 nodes distant from less than 'eps' and with value different with more than 'epsOnVals' an exception will be thrown. + * Merges coincident nodes of the underlying mesh. If some nodes are coincident, the + * underlying mesh is replaced by a new mesh instance where the coincident nodes are + * merged.
+ * In contrast to mergeNodes(), location of merged nodes is changed to be at their barycenter. + * \param [in] eps - a precision used to compare nodes of the two meshes. + * \param [in] epsOnVals - a precision used to compare field + * values at merged nodes. If the values differ more than \a epsOnVals, an + * exception is thrown. + * \return bool - \c true if some nodes have been merged and hence \a this field lies + * on another mesh. + * \throw If the mesh is of type not inheriting from MEDCouplingPointSet. + * \throw If the mesh is not well defined. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the data array is not set. + * \throw If field values at merged nodes (if any) deffer more than \a epsOnVals. */ bool MEDCouplingFieldDouble::mergeNodes2(double eps, double epsOnVals) throw(INTERP_KERNEL::Exception) { @@ -1514,9 +2131,19 @@ bool MEDCouplingFieldDouble::mergeNodes2(double eps, double epsOnVals) throw(INT } /*! - * This method applyies ParaMEDMEM::MEDCouplingPointSet::zipCoords method on 'this->_mesh' that should be set and of type ParaMEDMEM::MEDCouplingPointSet. - * If some nodes have disappeared true is returned. - * 'epsOnVals' stands for epsilon in case of merge of cells. This value is used as tolerance in case the corresponding values differ. + * Removes from the underlying mesh nodes not used in any cell. If some nodes are + * removed, the underlying mesh is replaced by a new mesh instance where the unused + * nodes are removed.
+ * \param [in] epsOnVals - a precision used to compare field + * values at merged nodes. If the values differ more than \a epsOnVals, an + * exception is thrown. + * \return bool - \c true if some nodes have been removed and hence \a this field lies + * on another mesh. + * \throw If the mesh is of type not inheriting from MEDCouplingPointSet. + * \throw If the mesh is not well defined. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the data array is not set. + * \throw If field values at merged nodes (if any) deffer more than \a epsOnVals. */ bool MEDCouplingFieldDouble::zipCoords(double epsOnVals) throw(INTERP_KERNEL::Exception) { @@ -1542,9 +2169,22 @@ bool MEDCouplingFieldDouble::zipCoords(double epsOnVals) throw(INTERP_KERNEL::Ex } /*! - * This method applyies ParaMEDMEM::MEDCouplingUMesh::zipConnectivityTraducer on 'this->_mesh' that should be set and of type ParaMEDMEM::MEDCouplingUMesh. - * The semantic of 'compType' is given in ParaMEDMEM::MEDCouplingUMesh::zipConnectivityTraducer method. - * 'epsOnVals' stands for epsilon in case of merge of cells. This value is used as tolerance in case the corresponding values differ. + * Removes duplicates of cells from the understanding mesh. If some cells are + * removed, the underlying mesh is replaced by a new mesh instance where the cells + * duplicates are removed.
+ * \param [in] compType - specifies a cell comparison technique. Meaning of its + * valid values [0,1,2] is explained in the description of + * MEDCouplingUMesh::zipConnectivityTraducer() which is called by this method. + * \param [in] epsOnVals - a precision used to compare field + * values at merged cells. If the values differ more than \a epsOnVals, an + * exception is thrown. + * \return bool - \c true if some cells have been removed and hence \a this field lies + * on another mesh. + * \throw If the mesh is not an instance of MEDCouplingUMesh. + * \throw If the mesh is not well defined. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the data array is not set. + * \throw If field values at merged cells (if any) deffer more than \a epsOnVals. */ bool MEDCouplingFieldDouble::zipConnectivity(int compType, double epsOnVals) throw(INTERP_KERNEL::Exception) { @@ -1608,8 +2248,19 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::extractSlice3D(const double *ori } /*! - * This method applyies ParaMEDMEM::MEDCouplingUMesh::simplexize on 'this->_mesh'. - * The semantic of 'policy' is given in ParaMEDMEM::MEDCouplingUMesh::simplexize method. + * Divides every cell of the underlying mesh into simplices (triangles in 2D and + * tetrahedra in 3D). If some cells are divided, the underlying mesh is replaced by a new + * mesh instance containing the simplices.
+ * \param [in] policy - specifies a pattern used for splitting. For its description, see + * MEDCouplingUMesh::simplexize(). + * \return bool - \c true if some cells have been divided and hence \a this field lies + * on another mesh. + * \throw If \a policy has an invalid value. For valid values, see the description of + * MEDCouplingUMesh::simplexize(). + * \throw If MEDCouplingMesh::simplexize() is not applicable to the underlying mesh. + * \throw If the mesh is not well defined. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If the data array is not set. */ bool MEDCouplingFieldDouble::simplexize(int policy) throw(INTERP_KERNEL::Exception) { @@ -1632,6 +2283,17 @@ bool MEDCouplingFieldDouble::simplexize(int policy) throw(INTERP_KERNEL::Excepti return true; } +/*! + * Creates a new MEDCouplingFieldDouble filled with the doubly contracted product of + * every tensor of \a this 6-componental field. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble, whose + * each tuple is calculated from the tuple (t) of \a this field as + * follows: \f$ t[0]^2+t[1]^2+t[2]^2+2*t[3]^2+2*t[4]^2+2*t[5]^2\f$. + * This new field lies on the same mesh as \a this one. The caller is to delete + * this field using decrRef() as it is no more needed. + * \throw If \a this->getNumberOfComponents() != 6. + * \throw If the spatial discretization of \a this field is NULL. + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::doublyContractedProduct() const throw(INTERP_KERNEL::Exception) { if(!((const MEDCouplingFieldDiscretization *)_type)) @@ -1644,6 +2306,17 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::doublyContractedProduct() const return ret.retn(); } +/*! + * Creates a new MEDCouplingFieldDouble filled with the determinant of a square + * matrix defined by every tuple of \a this field, having either 4, 6 or 9 components. + * The case of 6 components corresponds to that of the upper triangular matrix. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble, whose + * each tuple is the determinant of matrix of the corresponding tuple of \a this + * field. This new field lies on the same mesh as \a this one. The caller is to + * delete this field using decrRef() as it is no more needed. + * \throw If \a this->getNumberOfComponents() is not in [4,6,9]. + * \throw If the spatial discretization of \a this field is NULL. + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::determinant() const throw(INTERP_KERNEL::Exception) { if(!((const MEDCouplingFieldDiscretization *)_type)) @@ -1656,6 +2329,18 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::determinant() const throw(INTERP return ret.retn(); } + +/*! + * Creates a new MEDCouplingFieldDouble with 3 components filled with 3 eigenvalues of + * an upper triangular matrix defined by every tuple of \a this 6-componental field. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble, + * having 3 components, whose each tuple contains the eigenvalues of the matrix of + * corresponding tuple of \a this field. This new field lies on the same mesh as + * \a this one. The caller is to delete this field using decrRef() as it is no + * more needed. + * \throw If \a this->getNumberOfComponents() != 6. + * \throw If the spatial discretization of \a this field is NULL. + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::eigenValues() const throw(INTERP_KERNEL::Exception) { if(!((const MEDCouplingFieldDiscretization *)_type)) @@ -1668,6 +2353,17 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::eigenValues() const throw(INTERP return ret.retn(); } +/*! + * Creates a new MEDCouplingFieldDouble with 9 components filled with 3 eigenvectors of + * an upper triangular matrix defined by every tuple of \a this 6-componental field. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble, + * having 9 components, whose each tuple contains the eigenvectors of the matrix of + * corresponding tuple of \a this field. This new field lies on the same mesh as + * \a this one. The caller is to delete this field using decrRef() as it is no + * more needed. + * \throw If \a this->getNumberOfComponents() != 6. + * \throw If the spatial discretization of \a this field is NULL. + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::eigenVectors() const throw(INTERP_KERNEL::Exception) { if(!((const MEDCouplingFieldDiscretization *)_type)) @@ -1680,6 +2376,19 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::eigenVectors() const throw(INTER return ret.retn(); } +/*! + * Creates a new MEDCouplingFieldDouble filled with the inverse matrix of + * a matrix defined by every tuple of \a this field having either 4, 6 or 9 + * components. The case of 6 components corresponds to that of the upper triangular + * matrix. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble, + * having the same number of components as \a this one, whose each tuple + * contains the inverse matrix of the matrix of corresponding tuple of \a this + * field. This new field lies on the same mesh as \a this one. The caller is to + * delete this field using decrRef() as it is no more needed. + * \throw If \a this->getNumberOfComponents() is not in [4,6,9]. + * \throw If the spatial discretization of \a this field is NULL. + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::inverse() const throw(INTERP_KERNEL::Exception) { if(!((const MEDCouplingFieldDiscretization *)_type)) @@ -1692,6 +2401,19 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::inverse() const throw(INTERP_KER return ret.retn(); } +/*! + * Creates a new MEDCouplingFieldDouble filled with the trace of + * a matrix defined by every tuple of \a this field having either 4, 6 or 9 + * components. The case of 6 components corresponds to that of the upper triangular + * matrix. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble, + * having 1 component, whose each tuple is the trace of the matrix of + * corresponding tuple of \a this field. + * This new field lies on the same mesh as \a this one. The caller is to + * delete this field using decrRef() as it is no more needed. + * \throw If \a this->getNumberOfComponents() is not in [4,6,9]. + * \throw If the spatial discretization of \a this field is NULL. + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::trace() const throw(INTERP_KERNEL::Exception) { if(!((const MEDCouplingFieldDiscretization *)_type)) @@ -1704,6 +2426,18 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::trace() const throw(INTERP_KERNE return ret.retn(); } +/*! + * Creates a new MEDCouplingFieldDouble filled with the stress deviator tensor of + * a stress tensor defined by every tuple of \a this 6-componental field. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble, + * having same number of components and tuples as \a this field, + * whose each tuple contains the stress deviator tensor of the stress tensor of + * corresponding tuple of \a this field. This new field lies on the same mesh as + * \a this one. The caller is to delete this field using decrRef() as it is no + * more needed. + * \throw If \a this->getNumberOfComponents() != 6. + * \throw If the spatial discretization of \a this field is NULL. + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::deviator() const throw(INTERP_KERNEL::Exception) { if(!((const MEDCouplingFieldDiscretization *)_type)) @@ -1716,6 +2450,16 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::deviator() const throw(INTERP_KE return ret.retn(); } +/*! + * Creates a new MEDCouplingFieldDouble filled with the magnitude of + * every vector of \a this field. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble, + * having one component, whose each tuple is the magnitude of the vector + * of corresponding tuple of \a this field. This new field lies on the + * same mesh as \a this one. The caller is to + * delete this field using decrRef() as it is no more needed. + * \throw If the spatial discretization of \a this field is NULL. + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::magnitude() const throw(INTERP_KERNEL::Exception) { if(!((const MEDCouplingFieldDiscretization *)_type)) @@ -1728,6 +2472,14 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::magnitude() const throw(INTERP_K return ret.retn(); } +/*! + * Creates a new scalar MEDCouplingFieldDouble filled with the maximal value among + * values of every tuple of \a this field. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble. + * This new field lies on the same mesh as \a this one. The caller is to + * delete this field using decrRef() as it is no more needed. + * \throw If the spatial discretization of \a this field is NULL. + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::maxPerTuple() const throw(INTERP_KERNEL::Exception) { if(!((const MEDCouplingFieldDiscretization *)_type)) @@ -1742,11 +2494,33 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::maxPerTuple() const throw(INTERP return ret.retn(); } +/*! + * Changes number of components in \a this field. If \a newNbOfComp is less + * than \a this->getNumberOfComponents() then each tuple + * is truncated to have \a newNbOfComp components, keeping first components. If \a + * newNbOfComp is more than \a this->getNumberOfComponents() then + * each tuple is populated with \a dftValue to have \a newNbOfComp components. + * \param [in] newNbOfComp - number of components for the new field to have. + * \param [in] dftValue - value assigned to new values added to \a this field. + * \throw If \a this is not allocated. + */ void MEDCouplingFieldDouble::changeNbOfComponents(int newNbOfComp, double dftValue) throw(INTERP_KERNEL::Exception) { _time_discr->changeNbOfComponents(newNbOfComp,dftValue); } +/*! + * Creates a new MEDCouplingFieldDouble composed of selected components of \a this field. + * The new MEDCouplingFieldDouble has the same number of tuples but includes components + * specified by \a compoIds parameter. So that getNbOfElems() of the result field + * can be either less, same or more than \a this->getNumberOfValues(). + * \param [in] compoIds - sequence of zero based indices of components to include + * into the new field. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble that the caller + * is to delete using decrRef() as it is no more needed. + * \throw If a component index (\a i) is not valid: + * \a i < 0 || \a i >= \a this->getNumberOfComponents(). + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::keepSelectedComponents(const std::vector& compoIds) const throw(INTERP_KERNEL::Exception) { if(!((const MEDCouplingFieldDiscretization *)_type)) @@ -1759,16 +2533,51 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::keepSelectedComponents(const std return ret.retn(); } + +/*! + * Copy all components in a specified order from another field. + * The number of tuples in \a this and the other field can be different. + * \param [in] f - the field to copy data from. + * \param [in] compoIds - sequence of zero based indices of components, data of which is + * to be copied. + * \throw If the two fields have different number of data arrays. + * \throw If a data array is set in one of fields and is not set in the other. + * \throw If \a compoIds.size() != \a a->getNumberOfComponents(). + * \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents(). + */ void MEDCouplingFieldDouble::setSelectedComponents(const MEDCouplingFieldDouble *f, const std::vector& compoIds) throw(INTERP_KERNEL::Exception) { _time_discr->setSelectedComponents(f->_time_discr,compoIds); } +/*! + * Sorts value within every tuple of \a this field. + * \param [in] asc - if \a true, the values are sorted in ascending order, else, + * in descending order. + * \throw If a data array is not allocated. + */ void MEDCouplingFieldDouble::sortPerTuple(bool asc) throw(INTERP_KERNEL::Exception) { _time_discr->sortPerTuple(asc); } +/*! + * Creates a new MEDCouplingFieldDouble by concatenating two given fields. + * Values of + * the first field precede values of the second field within the result field. + * \param [in] f1 - the first field. + * \param [in] f2 - the second field. + * \return MEDCouplingFieldDouble * - the result field. It is a new instance of + * MEDCouplingFieldDouble. The caller is to delete this mesh using decrRef() + * as it is no more needed. + * \throw If the fields are not compatible for the merge. + * \throw If \a f2->getMesh() == NULL. + * \throw If the spatial discretization of \a f1 is NULL. + * \throw If the time discretization of \a f1 is NULL. + * + * \ref cpp_mcfielddouble_MergeFields "Here is a C++ example".
+ * \ref py_mcfielddouble_MergeFields "Here is a Python example". + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::MergeFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception) { if(!f1->areCompatibleForMerge(f2)) @@ -1792,10 +2601,22 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::MergeFields(const MEDCouplingFie } /*! - * This method returns a newly created field that is the union of all fields in input array 'a'. - * This method expects that 'a' is non empty. If not an exception will be thrown. - * If there is only one field in 'a' a deepCopy (except time information of mesh and field) of the unique field instance in 'a' will be returned. - * Generally speaking the first instance field in 'a' will be used to assign tiny attributes of returned field. + * Creates a new MEDCouplingFieldDouble by concatenating all given fields. + * Values of the *i*-th field precede values of the (*i*+1)-th field within the result. + * If there is only one field in \a a, a deepCopy() (except time information of mesh and + * field) of the field is returned. + * Generally speaking the first field in \a a is used to assign tiny attributes of the + * returned field. + * \param [in] a - a vector of fields (MEDCouplingFieldDouble) to concatenate. + * \return MEDCouplingFieldDouble * - the result field. It is a new instance of + * MEDCouplingFieldDouble. The caller is to delete this mesh using decrRef() + * as it is no more needed. + * \throw If \a a is empty. + * \throw If the fields are not compatible for the merge. + * \throw If \a a[ i ]->getMesh() == NULL. + * + * \ref cpp_mcfielddouble_MergeFields "Here is a C++ example".
+ * \ref py_mcfielddouble_MergeFields "Here is a Python example". */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::MergeFields(const std::vector& a) throw(INTERP_KERNEL::Exception) { @@ -1830,6 +2651,21 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::MergeFields(const std::vectorgetNumberOfTuples() != \a f2->getNumberOfTuples() + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::MeldFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception) { if(!f1->areCompatibleForMeld(f2)) @@ -1841,6 +2677,20 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::MeldFields(const MEDCouplingFiel return ret.retn(); } +/*! + * Returns a new MEDCouplingFieldDouble containing a dot product of two given fields, + * so that the i-th tuple of the result field is a sum of products of j-th components of + * i-th tuples of given fields (\f$ f_i = \sum_{j=1}^n f1_j * f2_j \f$). + * Number of tuples and components in the given fields must be the same. + * \param [in] f1 - a given field. + * \param [in] f2 - another given field. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble. + * The caller is to delete this result field using decrRef() as it is no more + * needed. + * \throw If either \a f1 or \a f2 is NULL. + * \throw If the fields are not strictly compatible (areStrictlyCompatible()), i.e. they + * differ not only in values. + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::DotFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception) { if(!f1) @@ -1854,6 +2704,24 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::DotFields(const MEDCouplingField return ret; } +/*! + * Returns a new MEDCouplingFieldDouble containing a cross product of two given fields, + * so that + * the i-th tuple of the result field is a 3D vector which is a cross + * product of two vectors defined by the i-th tuples of given fields. + * Number of tuples in the given fields must be the same. + * Number of components in the given fields must be 3. + * \param [in] f1 - a given field. + * \param [in] f2 - another given field. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble. + * The caller is to delete this result field using decrRef() as it is no more + * needed. + * \throw If either \a f1 or \a f2 is NULL. + * \throw If \a f1->getNumberOfComponents() != 3 + * \throw If \a f2->getNumberOfComponents() != 3 + * \throw If the fields are not strictly compatible (areStrictlyCompatible()), i.e. they + * differ not only in values. + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::CrossProductFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception) { if(!f1) @@ -1867,6 +2735,21 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::CrossProductFields(const MEDCoup return ret.retn(); } +/*! + * Returns a new MEDCouplingFieldDouble containing maximal values of two given fields. + * Number of tuples and components in the given fields must be the same. + * \param [in] f1 - a field to compare values with another one. + * \param [in] f2 - another field to compare values with the first one. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble. + * The caller is to delete this result field using decrRef() as it is no more + * needed. + * \throw If either \a f1 or \a f2 is NULL. + * \throw If the fields are not strictly compatible (areStrictlyCompatible()), i.e. they + * differ not only in values. + * + * \ref cpp_mcfielddouble_MaxFields "Here is a C++ example".
+ * \ref py_mcfielddouble_MaxFields "Here is a Python example". + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::MaxFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception) { if(!f1) @@ -1880,6 +2763,21 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::MaxFields(const MEDCouplingField return ret.retn(); } +/*! + * Returns a new MEDCouplingFieldDouble containing minimal values of two given fields. + * Number of tuples and components in the given fields must be the same. + * \param [in] f1 - a field to compare values with another one. + * \param [in] f2 - another field to compare values with the first one. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble. + * The caller is to delete this result field using decrRef() as it is no more + * needed. + * \throw If either \a f1 or \a f2 is NULL. + * \throw If the fields are not strictly compatible (areStrictlyCompatible()), i.e. they + * differ not only in values. + * + * \ref cpp_mcfielddouble_MaxFields "Here is a C++ example".
+ * \ref py_mcfielddouble_MaxFields "Here is a Python example". + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::MinFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception) { if(!f1) @@ -1893,6 +2791,15 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::MinFields(const MEDCouplingField return ret.retn(); } +/*! + * Returns a copy of \a this field in which sign of all values is reversed. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble + * containing the same number of tuples and components as \a this field. + * The caller is to delete this result field using decrRef() as it is no more + * needed. + * \throw If the spatial discretization of \a this field is NULL. + * \throw If a data array is not allocated. + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::negate() const throw(INTERP_KERNEL::Exception) { if(!((const MEDCouplingFieldDiscretization *)_type)) @@ -1904,6 +2811,19 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::negate() const throw(INTERP_KERN return ret.retn(); } +/*! + * Returns a new MEDCouplingFieldDouble containing sum values of corresponding values of + * two given fields ( _f_ [ i, j ] = _f1_ [ i, j ] + _f2_ [ i, j ] ). + * Number of tuples and components in the given fields must be the same. + * \param [in] f1 - a field to sum up. + * \param [in] f2 - another field to sum up. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble. + * The caller is to delete this result field using decrRef() as it is no more + * needed. + * \throw If either \a f1 or \a f2 is NULL. + * \throw If the fields are not strictly compatible (areStrictlyCompatible()), i.e. they + * differ not only in values. + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::AddFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception) { if(!f1) @@ -1917,6 +2837,16 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::AddFields(const MEDCouplingField return ret.retn(); } +/*! + * Adds values of another MEDCouplingFieldDouble to values of \a this one + * ( _this_ [ i, j ] += _other_ [ i, j ] ) using DataArrayDouble::addEqual(). + * The two fields must have same number of tuples, components and same underlying mesh. + * \param [in] other - the field to add to \a this one. + * \return const MEDCouplingFieldDouble & - a reference to \a this field. + * \throw If \a other is NULL. + * \throw If the fields are not strictly compatible (areStrictlyCompatible()), i.e. they + * differ not only in values. + */ const MEDCouplingFieldDouble &MEDCouplingFieldDouble::operator+=(const MEDCouplingFieldDouble& other) throw(INTERP_KERNEL::Exception) { if(!areStrictlyCompatible(&other)) @@ -1925,6 +2855,19 @@ const MEDCouplingFieldDouble &MEDCouplingFieldDouble::operator+=(const MEDCoupli return *this; } +/*! + * Returns a new MEDCouplingFieldDouble containing subtraction of corresponding values of + * two given fields ( _f_ [ i, j ] = _f1_ [ i, j ] - _f2_ [ i, j ] ). + * Number of tuples and components in the given fields must be the same. + * \param [in] f1 - a field to subtract from. + * \param [in] f2 - a field to subtract. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble. + * The caller is to delete this result field using decrRef() as it is no more + * needed. + * \throw If either \a f1 or \a f2 is NULL. + * \throw If the fields are not strictly compatible (areStrictlyCompatible()), i.e. they + * differ not only in values. + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::SubstractFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception) { if(!f1) @@ -1938,6 +2881,16 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::SubstractFields(const MEDCouplin return ret.retn(); } +/*! + * Subtract values of another MEDCouplingFieldDouble from values of \a this one + * ( _this_ [ i, j ] -= _other_ [ i, j ] ) using DataArrayDouble::substractEqual(). + * The two fields must have same number of tuples, components and same underlying mesh. + * \param [in] other - the field to subtract from \a this one. + * \return const MEDCouplingFieldDouble & - a reference to \a this field. + * \throw If \a other is NULL. + * \throw If the fields are not strictly compatible (areStrictlyCompatible()), i.e. they + * differ not only in values. + */ const MEDCouplingFieldDouble &MEDCouplingFieldDouble::operator-=(const MEDCouplingFieldDouble& other) throw(INTERP_KERNEL::Exception) { if(!areStrictlyCompatible(&other)) @@ -1946,6 +2899,26 @@ const MEDCouplingFieldDouble &MEDCouplingFieldDouble::operator-=(const MEDCoupli return *this; } +/*! + * Returns a new MEDCouplingFieldDouble containing product values of + * two given fields. There are 2 valid cases. + * 1. The fields have same number of tuples and components. Then each value of + * the result field (_f_) is a product of the corresponding values of _f1_ and + * _f2_, i.e. _f_ [ i, j ] = _f1_ [ i, j ] * _f2_ [ i, j ]. + * 2. The fields have same number of tuples and one field, say _f2_, has one + * component. Then + * _f_ [ i, j ] = _f1_ [ i, j ] * _f2_ [ i, 0 ]. + * + * The two fields must have same number of tuples and same underlying mesh. + * \param [in] f1 - a factor field. + * \param [in] f2 - another factor field. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble. + * The caller is to delete this result field using decrRef() as it is no more + * needed. + * \throw If either \a f1 or \a f2 is NULL. + * \throw If the fields are not compatible for production (areCompatibleForMul()), + * i.e. they differ not only in values and possibly number of components. + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::MultiplyFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception) { if(!f1) @@ -1959,6 +2932,27 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::MultiplyFields(const MEDCoupling return ret.retn(); } +/*! + * Multiply values of another MEDCouplingFieldDouble to values of \a this one + * using DataArrayDouble::multiplyEqual(). + * The two fields must have same number of tuples and same underlying mesh. + * There are 2 valid cases. + * 1. The fields have same number of components. Then each value of + * \a other is multiplied to the corresponding value of \a this field, i.e. + * _this_ [ i, j ] *= _other_ [ i, j ]. + * 2. The _other_ field has one component. Then + * _this_ [ i, j ] *= _other_ [ i, 0 ]. + * + * The two fields must have same number of tuples and same underlying mesh. + * \param [in] other - an field to multiply to \a this one. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble. + * The caller is to delete this result field using decrRef() as it is no more + * needed. + * \throw If \a other is NULL. + * \throw If the fields are not strictly compatible for production + * (areCompatibleForMul()), + * i.e. they differ not only in values and possibly in number of components. + */ const MEDCouplingFieldDouble &MEDCouplingFieldDouble::operator*=(const MEDCouplingFieldDouble& other) throw(INTERP_KERNEL::Exception) { if(!areCompatibleForMul(&other)) @@ -1967,6 +2961,24 @@ const MEDCouplingFieldDouble &MEDCouplingFieldDouble::operator*=(const MEDCoupli return *this; } +/*! + * Returns a new MEDCouplingFieldDouble containing division of two given fields. + * There are 2 valid cases. + * 1. The fields have same number of tuples and components. Then each value of + * the result field (_f_) is a division of the corresponding values of \a f1 and + * \a f2, i.e. _f_ [ i, j ] = _f1_ [ i, j ] / _f2_ [ i, j ]. + * 2. The fields have same number of tuples and _f2_ has one component. Then + * _f_ [ i, j ] = _f1_ [ i, j ] / _f2_ [ i, 0 ]. + * + * \param [in] f1 - a numerator field. + * \param [in] f2 - a denominator field. + * \return MEDCouplingFieldDouble * - the new instance of MEDCouplingFieldDouble. + * The caller is to delete this result field using decrRef() as it is no more + * needed. + * \throw If either \a f1 or \a f2 is NULL. + * \throw If the fields are not compatible for division (areCompatibleForDiv()), + * i.e. they differ not only in values and possibly in number of components. + */ MEDCouplingFieldDouble *MEDCouplingFieldDouble::DivideFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception) { if(!f1) @@ -1980,6 +2992,23 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::DivideFields(const MEDCouplingFi return ret.retn(); } +/*! + * Divide values of \a this field by values of another MEDCouplingFieldDouble + * using DataArrayDouble::divideEqual(). + * The two fields must have same number of tuples and same underlying mesh. + * There are 2 valid cases. + * 1. The fields have same number of components. Then each value of + * \a this field is divided by the corresponding value of \a other one, i.e. + * _this_ [ i, j ] /= _other_ [ i, j ]. + * 2. The \a other field has one component. Then + * _this_ [ i, j ] /= _other_ [ i, 0 ]. + * + * \warning No check of division by zero is performed! + * \param [in] other - an field to divide \a this one by. + * \throw If \a other is NULL. + * \throw If the fields are not compatible for division (areCompatibleForDiv()), + * i.e. they differ not only in values and possibly in number of components. + */ const MEDCouplingFieldDouble &MEDCouplingFieldDouble::operator/=(const MEDCouplingFieldDouble& other) throw(INTERP_KERNEL::Exception) { if(!areCompatibleForDiv(&other)) @@ -2025,10 +3054,19 @@ const MEDCouplingFieldDouble &MEDCouplingFieldDouble::operator^=(const MEDCoupli } /*! - * This method writes the field series 'fs' in the VTK file 'fileName'. - * If 'fs' is empty no file is written. If fields lies on more than one mesh an exception will be thrown and no file will be written too. - * If the single mesh is empty an exception will be thrown. - * Finally there is a field in 'fs' with no name an exception will be thrown too. + * Writes the field series \a fs and the mesh the fields lie on in the VTK file \a fileName. + * If \a fs is empty no file is written. + * The result file is valid provided that no exception is thrown. + * \warning All the fields must be named and lie on the same non NULL mesh. + * \param [in] fileName - the name of a VTK file to write in. + * \param [in] fs - the fields to write. + * \throw If \a fs[ 0 ] == NULL. + * \throw If the fields lie not on the same mesh. + * \throw If the mesh is not set. + * \throw If any of the fields has no name. + * + * \ref cpp_mcfielddouble_WriteVTK "Here is a C++ example".
+ * \ref py_mcfielddouble_WriteVTK "Here is a Python example". */ void MEDCouplingFieldDouble::WriteVTK(const char *fileName, const std::vector& fs) throw(INTERP_KERNEL::Exception) { diff --git a/src/MEDCoupling/MEDCouplingFieldDouble.hxx b/src/MEDCoupling/MEDCouplingFieldDouble.hxx index 6e3c3282f..61ee004f8 100644 --- a/src/MEDCoupling/MEDCouplingFieldDouble.hxx +++ b/src/MEDCoupling/MEDCouplingFieldDouble.hxx @@ -112,7 +112,6 @@ namespace ParaMEDMEM void getValueOn(const double *spaceLoc, double *res) const throw(INTERP_KERNEL::Exception); void getValueOn(const double *spaceLoc, double time, double *res) const throw(INTERP_KERNEL::Exception); DataArrayDouble *getValueOnMulti(const double *spaceLoc, int nbOfPoints) const throw(INTERP_KERNEL::Exception); - //! \b temporary void applyLin(double a, double b, int compoId); MEDCouplingFieldDouble &operator=(double value) throw(INTERP_KERNEL::Exception); void fillFromAnalytic(int nbOfComp, FunctionToEvaluate func) throw(INTERP_KERNEL::Exception); diff --git a/src/MEDCoupling/MEDCouplingMemArray.cxx b/src/MEDCoupling/MEDCouplingMemArray.cxx index abfc07b23..2f09e0f6e 100644 --- a/src/MEDCoupling/MEDCouplingMemArray.cxx +++ b/src/MEDCoupling/MEDCouplingMemArray.cxx @@ -1934,7 +1934,6 @@ DataArrayDouble *DataArrayDouble::getDifferentValues(double prec, int limitTuple /*! * Copy all components in a specified order from another DataArrayDouble. - * The specified components become the first ones in \a this array. * Both numerical and textual data is copied. The number of tuples in \a this and * the other array can be different. * \param [in] a - the array to copy data from. @@ -4655,7 +4654,7 @@ void DataArrayDouble::substractEqual(const DataArrayDouble *other) throw(INTERP_ * valid cases. * 1. The arrays have same number of tuples and components. Then each value of * the result array (_a_) is a product of the corresponding values of \a a1 and - * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ]. + * \a a2, i.e. _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ]. * 2. The arrays have same number of tuples and one array, say _a2_, has one * component. Then * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ]. @@ -4749,12 +4748,12 @@ DataArrayDouble *DataArrayDouble::Multiply(const DataArrayDouble *a1, const Data * Multiply values of another DataArrayDouble to values of \a this one. There are 3 * valid cases. * 1. The arrays have same number of tuples and components. Then each value of - * \a other array is multiplied to the corresponding value of \a this array, i.e.: - * _a_ [ i, j ] *= _other_ [ i, j ]. + * \a other array is multiplied to the corresponding value of \a this array, i.e. + * _this_ [ i, j ] *= _other_ [ i, j ]. * 2. The arrays have same number of tuples and \a other array has one component. Then - * _a_ [ i, j ] *= _other_ [ i, 0 ]. + * _this_ [ i, j ] *= _other_ [ i, 0 ]. * 3. The arrays have same number of components and \a other array has one tuple. Then - * _a_ [ i, j ] *= _a2_ [ 0, j ]. + * _this_ [ i, j ] *= _a2_ [ 0, j ]. * * \param [in] other - an array to multiply to \a this one. * \throw If \a other is NULL. diff --git a/src/MEDCoupling/MEDCouplingMemArray.hxx b/src/MEDCoupling/MEDCouplingMemArray.hxx index d6d44aeec..f42d1a32d 100644 --- a/src/MEDCoupling/MEDCouplingMemArray.hxx +++ b/src/MEDCoupling/MEDCouplingMemArray.hxx @@ -54,7 +54,9 @@ namespace ParaMEDMEM class MemArray { public: - MemArray():_nb_of_elem(0),_nb_of_elem_alloc(0),_ownership(false),_dealloc(CPP_DEALLOC) { } + typedef void (*Deallocator)(void *,void *); + public: + MemArray():_nb_of_elem(0),_nb_of_elem_alloc(0),_ownership(false),_dealloc(0),_param_for_deallocator(0) { } MemArray(const MemArray& other); bool isNull() const { return _pointer.isNull(); } const T *getConstPointerLoc(std::size_t offset) const { return _pointer.getConstPointerLoc(offset); } @@ -85,16 +87,25 @@ namespace ParaMEDMEM void pushBack(T elem) throw(INTERP_KERNEL::Exception); T popBack() throw(INTERP_KERNEL::Exception); void pack() const; + bool isDeallocatorCalled() const { return _ownership; } + Deallocator getDeallocator() const { return _dealloc; } + void setSpecificDeallocator(Deallocator dealloc) { _dealloc=dealloc; } + void setParameterForDeallocator(void *param) { _param_for_deallocator=param; } + void destroy(); ~MemArray() { destroy(); } + public: + static void CPPDeallocator(void *pt, void *param); + static void CDeallocator(void *pt, void *param); private: - void destroy(); - static void destroyPointer(T *pt, DeallocType type); + static void destroyPointer(T *pt, Deallocator dealloc, void *param); + static Deallocator BuildFromType(DeallocType type) throw(INTERP_KERNEL::Exception); private: std::size_t _nb_of_elem; std::size_t _nb_of_elem_alloc; bool _ownership; MEDCouplingPointer _pointer; - DeallocType _dealloc; + Deallocator _dealloc; + void *_param_for_deallocator; }; class DataArray : public RefCountObject, public TimeLabel @@ -321,6 +332,8 @@ namespace ParaMEDMEM MEDCOUPLING_EXPORT static DataArrayDouble *Pow(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception); MEDCOUPLING_EXPORT void powEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception); MEDCOUPLING_EXPORT void updateTime() const { } + MEDCOUPLING_EXPORT MemArray& accessToMemArray() { return _mem; } + MEDCOUPLING_EXPORT const MemArray& accessToMemArray() const { return _mem; } public: MEDCOUPLING_EXPORT void getTinySerializationIntInformation(std::vector& tinyInfo) const; MEDCOUPLING_EXPORT void getTinySerializationStrInformation(std::vector& tinyInfo) const; @@ -548,6 +561,8 @@ namespace ParaMEDMEM MEDCOUPLING_EXPORT static DataArrayInt *Pow(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception); MEDCOUPLING_EXPORT void powEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception); MEDCOUPLING_EXPORT void updateTime() const { } + MEDCOUPLING_EXPORT MemArray& accessToMemArray() { return _mem; } + MEDCOUPLING_EXPORT const MemArray& accessToMemArray() const { return _mem; } public: MEDCOUPLING_EXPORT static int *CheckAndPreparePermutation(const int *start, const int *end); MEDCOUPLING_EXPORT static DataArrayInt *Range(int begin, int end, int step) throw(INTERP_KERNEL::Exception); @@ -678,6 +693,8 @@ namespace ParaMEDMEM MEDCOUPLING_EXPORT void useArray(const char *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception); MEDCOUPLING_EXPORT void useExternalArrayWithRWAccess(const char *array, int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception); MEDCOUPLING_EXPORT void updateTime() const { } + MEDCOUPLING_EXPORT MemArray& accessToMemArray() { return _mem; } + MEDCOUPLING_EXPORT const MemArray& accessToMemArray() const { return _mem; } public: //MEDCOUPLING_EXPORT void getTinySerializationIntInformation(std::vector& tinyInfo) const; //MEDCOUPLING_EXPORT void getTinySerializationStrInformation(std::vector& tinyInfo) const; diff --git a/src/MEDCoupling/MEDCouplingMemArray.txx b/src/MEDCoupling/MEDCouplingMemArray.txx index a3f4d2510..1cb03da77 100644 --- a/src/MEDCoupling/MEDCouplingMemArray.txx +++ b/src/MEDCoupling/MEDCouplingMemArray.txx @@ -46,7 +46,7 @@ namespace ParaMEDMEM } template - MemArray::MemArray(const MemArray& other):_nb_of_elem(0),_nb_of_elem_alloc(0),_ownership(false),_dealloc(CPP_DEALLOC) + MemArray::MemArray(const MemArray& other):_nb_of_elem(0),_nb_of_elem_alloc(0),_ownership(false),_dealloc(0),_param_for_deallocator(0) { if(!other._pointer.isNull()) { @@ -68,7 +68,7 @@ namespace ParaMEDMEM else _pointer.setExternal(array); _ownership=ownership; - _dealloc=type; + _dealloc=BuildFromType(type); } template @@ -79,7 +79,7 @@ namespace ParaMEDMEM destroy(); _pointer.setInternal(const_cast(array)); _ownership=false; - _dealloc=CPP_DEALLOC; + _dealloc=CPPDeallocator; } template @@ -342,7 +342,7 @@ namespace ParaMEDMEM _nb_of_elem_alloc=nbOfElements; _pointer.setInternal(new T[_nb_of_elem_alloc]); _ownership=true; - _dealloc=CPP_DEALLOC; + _dealloc=CPPDeallocator; } /*! @@ -364,12 +364,13 @@ namespace ParaMEDMEM T *pointer=new T[newNbOfElements]; std::copy(_pointer.getConstPointer(),_pointer.getConstPointer()+std::min(_nb_of_elem,newNbOfElements),pointer); if(_ownership) - destroyPointer(const_cast(_pointer.getConstPointer()),_dealloc);//Do not use getPointer because in case of _external + destroyPointer(const_cast(_pointer.getConstPointer()),_dealloc,_param_for_deallocator);//Do not use getPointer because in case of _external _pointer.setInternal(pointer); _nb_of_elem=std::min(_nb_of_elem,newNbOfElements); _nb_of_elem_alloc=newNbOfElements; _ownership=true; - _dealloc=CPP_DEALLOC; + _dealloc=CPPDeallocator; + _param_for_deallocator=0; } /*! @@ -389,43 +390,57 @@ namespace ParaMEDMEM T *pointer=new T[newNbOfElements]; std::copy(_pointer.getConstPointer(),_pointer.getConstPointer()+std::min(_nb_of_elem,newNbOfElements),pointer); if(_ownership) - destroyPointer(const_cast(_pointer.getConstPointer()),_dealloc);//Do not use getPointer because in case of _external + destroyPointer(const_cast(_pointer.getConstPointer()),_dealloc,_param_for_deallocator);//Do not use getPointer because in case of _external _pointer.setInternal(pointer); _nb_of_elem=newNbOfElements; _nb_of_elem_alloc=newNbOfElements; _ownership=true; - _dealloc=CPP_DEALLOC; + _dealloc=CPPDeallocator; + _param_for_deallocator=0; } template - void MemArray::destroyPointer(T *pt, DeallocType type) + void MemArray::CPPDeallocator(void *pt, void *param) + { + delete [] reinterpret_cast(pt); + } + + template + void MemArray::CDeallocator(void *pt, void *param) + { + free(pt); + } + + template + typename MemArray::Deallocator MemArray::BuildFromType(DeallocType type) throw(INTERP_KERNEL::Exception) { switch(type) { case CPP_DEALLOC: - { - delete [] pt; - return ; - } + return CPPDeallocator; case C_DEALLOC: - { - free(pt); - return ; - } + return CDeallocator; default: - std::ostringstream stream; - stream << "Invalid deallocation requested for pointer " << pt; - throw INTERP_KERNEL::Exception(stream.str().c_str()); + throw INTERP_KERNEL::Exception("Invalid deallocation requested ! Unrecognized enum DeallocType !"); } } + template + void MemArray::destroyPointer(T *pt, typename MemArray::Deallocator dealloc, void *param) + { + if(dealloc) + dealloc(pt,param); + } + template void MemArray::destroy() { if(_ownership) - destroyPointer(const_cast(_pointer.getConstPointer()),_dealloc);//Do not use getPointer because in case of _external + destroyPointer(const_cast(_pointer.getConstPointer()),_dealloc,_param_for_deallocator);//Do not use getPointer because in case of _external _pointer.null(); _ownership=false; + _dealloc=NULL; + _param_for_deallocator=NULL; } template diff --git a/src/MEDCoupling/MEDCouplingMesh.cxx b/src/MEDCoupling/MEDCouplingMesh.cxx index 1e1f6d278..48489218f 100644 --- a/src/MEDCoupling/MEDCouplingMesh.cxx +++ b/src/MEDCoupling/MEDCouplingMesh.cxx @@ -353,7 +353,8 @@ MEDCouplingFieldDouble *MEDCouplingMesh::fillFromAnalytic(TypeOfField t, int nbO * components, lying on \a this mesh, with contents got by applying a specified * function to coordinates of field location points (defined by the given field type). * For example, if \a t == ParaMEDMEM::ON_CELLS, the function is applied to cell - * barycenters. This method differs from \ref mcmesh_fillFromAnalytic "fillFromAnalytic() + * barycenters. This method differs from + * \ref MEDCouplingMesh::fillFromAnalytic(TypeOfField t, int nbOfComp, const char *func) const "fillFromAnalytic()" * by the way how variable * names, used in the function, are associated with components of coordinates of field * location points; here, a variable name corresponding to a component is retrieved from diff --git a/src/MEDCoupling/MEDCouplingUMesh.cxx b/src/MEDCoupling/MEDCouplingUMesh.cxx index d5425440e..7a715e20e 100644 --- a/src/MEDCoupling/MEDCouplingUMesh.cxx +++ b/src/MEDCoupling/MEDCouplingUMesh.cxx @@ -520,11 +520,14 @@ void MEDCouplingUMesh::checkDeepEquivalWith(const MEDCouplingMesh *other, int ce // da=m->zipConnectivityTraducer(cellCompPol); - int maxId=*std::max_element(da->getConstPointer(),da->getConstPointer()+getNumberOfCells()); - pt=std::find_if(da->getConstPointer()+getNumberOfCells(),da->getConstPointer()+da->getNbOfElems(),std::bind2nd(std::greater(),maxId)); + int nbCells=getNumberOfCells(); + int maxId=-1; + if(nbCells!=0) + maxId=*std::max_element(da->getConstPointer(),da->getConstPointer()+nbCells); + pt=std::find_if(da->getConstPointer()+nbCells,da->getConstPointer()+da->getNbOfElems(),std::bind2nd(std::greater(),maxId)); if(pt!=da->getConstPointer()+da->getNbOfElems()) throw INTERP_KERNEL::Exception("checkDeepEquivalWith : some cells in other are not in this !"); - MEDCouplingAutoRefCountObjectPtr cellCor2=da->selectByTupleId2(getNumberOfCells(),da->getNbOfElems(),1); + MEDCouplingAutoRefCountObjectPtr cellCor2=da->selectByTupleId2(nbCells,da->getNbOfElems(),1); nodeCor=nodeCor2->isIdentity()?0:nodeCor2.retn(); cellCor=cellCor2->isIdentity()?0:cellCor2.retn(); } @@ -576,8 +579,8 @@ void MEDCouplingUMesh::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *ot * Checks if \a this and \a other meshes are geometrically equivalent with high * probability, else an exception is thrown. The meshes are considered equivalent if * (1) meshes contain the same number of nodes and the same number of elements of the - * same types (2) three cells of the two meshes are based on coincident nodes (with a - * specified precision). + * same types (2) three cells of the two meshes (first, last and middle) are based + * on coincident nodes (with a specified precision). * \param [in] other - the mesh to compare with. * \param [in] prec - the precision used to compare nodes of the two meshes. * \throw If the two meshes do not match. @@ -2542,7 +2545,7 @@ MEDCouplingUMesh *MEDCouplingUMesh::computeSkin() const throw(INTERP_KERNEL::Exc * Finds nodes lying on the boundary of \a this mesh. * \return DataArrayInt * - a new instance of DataArrayInt holding ids of found * nodes. The caller is to delete this array using decrRef() as it is no - * more needed + * more needed. * \throw If the coordinates array is not set. * \throw If the nodal connectivity of cells is node defined. * diff --git a/src/MEDCoupling/Test/MEDCouplingExamplesTest.cxx b/src/MEDCoupling/Test/MEDCouplingExamplesTest.cxx index 3a1ed18a7..a98c000a0 100644 --- a/src/MEDCoupling/Test/MEDCouplingExamplesTest.cxx +++ b/src/MEDCoupling/Test/MEDCouplingExamplesTest.cxx @@ -27,7 +27,629 @@ #include "MEDCouplingMultiFields.hxx" -void CppExample_MEDCouplingPointSet_fillFromAnalytic3() +void CppExample_MEDCouplingFieldDouble_WriteVTK() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_WriteVTK_1] + // mesh1 + const double coords[3] = {0.,2.,4.}; + MEDCouplingAutoRefCountObjectPtr coordsArr = DataArrayDouble::New(); + coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 ); + MEDCouplingAutoRefCountObjectPtr mesh1 = MEDCouplingCMesh::New(); + mesh1->setCoords(coordsArr,coordsArr); // mesh becomes a 2D one + + // 3 fields (lying on the same mesh!) + MEDCouplingAutoRefCountObjectPtr field1 = + mesh1->getMeasureField( true ); + MEDCouplingAutoRefCountObjectPtr field2 = + mesh1->buildOrthogonalField(); + MEDCouplingAutoRefCountObjectPtr field3 = + mesh1->fillFromAnalytic( ON_CELLS, 1, "x"); + field2->setName( "Normal" ); // name is necessary! + field3->setName( "Barycenter" ); // name is necessary! + + // WriteVTK + const char fileName[] = "testExample_MEDCouplingFieldDouble_WriteVTK.vtk"; + std::vector fs( 3 ); // field series + fs[0] = field1; + fs[1] = field2; + fs[2] = field3; + MEDCouplingFieldDouble::WriteVTK( fileName, fs ); + //! [CppSnippet_MEDCouplingFieldDouble_WriteVTK_1] + remove(fileName); +} + +void CppExample_MEDCouplingFieldDouble_MaxFields() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_MaxFields_1] + const double vals1[4] = {0.,2., 4.,6.}; // for field 1 + const double vals2[4] = {2.,0., 6.,4.}; // for field 2 + const double valsMax[4] = {2.,2., 6.,6.}; // expected max field + const double valsMin[4] = {0.,0., 4.,4.}; // expected min field + // field 1 + MEDCouplingAutoRefCountObjectPtr valsArr1 = DataArrayDouble::New(); + valsArr1->useExternalArrayWithRWAccess( vals1, 2,2 ); // 2 tuples per 2 components + MEDCouplingAutoRefCountObjectPtr field1 = MEDCouplingFieldDouble::New( ON_NODES ); + field1->setArray( valsArr1 ); + // field 2 + MEDCouplingAutoRefCountObjectPtr valsArr2 = DataArrayDouble::New(); + valsArr2->useExternalArrayWithRWAccess( vals2, 2,2 ); // 2 tuples per 2 components + MEDCouplingAutoRefCountObjectPtr field2 = MEDCouplingFieldDouble::New( ON_NODES ); + field2->setArray( valsArr2 ); + // max field + MEDCouplingAutoRefCountObjectPtr fieldMax = MEDCouplingFieldDouble::MaxFields( field1, field2 ); + CPPUNIT_ASSERT( std::equal( valsMax, valsMax+4, fieldMax->getArray()->getConstPointer() )); // fieldMax == valsMax + // min field + MEDCouplingAutoRefCountObjectPtr fieldMin = MEDCouplingFieldDouble::MinFields( field1, field2 ); + CPPUNIT_ASSERT( std::equal( valsMin, valsMin+4, fieldMin->getArray()->getConstPointer() )); // fieldMin == valsMin + //! [CppSnippet_MEDCouplingFieldDouble_MaxFields_1] +} + +void CppExample_MEDCouplingFieldDouble_MergeFields() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_MergeFields_1] + // mesh1 + const double coords[3] = {0.,2.,4.}; + MEDCouplingAutoRefCountObjectPtr coordsArr = DataArrayDouble::New(); + coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 ); + MEDCouplingAutoRefCountObjectPtr mesh1 = MEDCouplingCMesh::New(); + mesh1->setCoords(coordsArr); // mesh becomes a 1D + // field1 + MEDCouplingAutoRefCountObjectPtr field1 = + mesh1->fillFromAnalytic( ON_CELLS, 1, "x"); + + // mesh2 and field2 + MEDCouplingAutoRefCountObjectPtr field2 = + field1->cloneWithMesh( true ); + double vec[1] = { 5. }; + ((ParaMEDMEM::MEDCouplingMesh *)field2->getMesh())->translate(vec); // translate mesh2 + field2->applyFunc("x + 5"); // "translate" field2 + + // concatenate field1 and field2 + MEDCouplingAutoRefCountObjectPtr field3 = + MEDCouplingFieldDouble::MergeFields( field1, field2 ); + std::vector fields( 2 ); + fields[0] = field1; + fields[1] = field2; + MEDCouplingAutoRefCountObjectPtr field4 = + MEDCouplingFieldDouble::MergeFields( fields ); + //! [CppSnippet_MEDCouplingFieldDouble_MergeFields_1] +} + +void CppExample_MEDCouplingFieldDouble_substractInPlaceDM() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_substractInPlaceDM_1] + const double coords1[4] = {0.,1.,2.,3.}; + const double coords2[4] = {2.,1.,0.,3.}; // #0 <==> #2 + // mesh 1 + MEDCouplingAutoRefCountObjectPtr mesh1 = MEDCouplingUMesh::New(); + MEDCouplingAutoRefCountObjectPtr coordsArr = DataArrayDouble::New(); + coordsArr->useExternalArrayWithRWAccess( coords1, 4, 1 ); + mesh1->setCoords(coordsArr); + mesh1->setMeshDimension(0); + mesh1->allocateCells(0); + mesh1->finishInsertingCells(); + // mesh 2 + MEDCouplingAutoRefCountObjectPtr mesh2 = + (MEDCouplingUMesh*) mesh1->deepCpy(); + mesh2->getCoords()->useExternalArrayWithRWAccess( coords2, 4, 1 ); + //! [CppSnippet_MEDCouplingFieldDouble_substractInPlaceDM_1] + //! [CppSnippet_MEDCouplingFieldDouble_substractInPlaceDM_2] + MEDCouplingAutoRefCountObjectPtr field1 = + mesh1->fillFromAnalytic( ParaMEDMEM::ON_NODES,1,"x"); // field1 values == coords1 + MEDCouplingAutoRefCountObjectPtr field2 = + mesh2->fillFromAnalytic( ParaMEDMEM::ON_NODES,1,"x"); // field2 values == coords2 + const double levOfCheck = 10; // nodes can be permuted + field1->substractInPlaceDM( field2, levOfCheck, 1e-13, 0 ); // values #0 and #2 must swap + //! [CppSnippet_MEDCouplingFieldDouble_substractInPlaceDM_2] + //! [CppSnippet_MEDCouplingFieldDouble_substractInPlaceDM_3] + field2->applyFunc( 1, 0.0 ); // all field2 values == 0.0 + CPPUNIT_ASSERT( field1->isEqual( field2, 1e-13, 1e-13 )); // field1 == field2 == 0.0 + //! [CppSnippet_MEDCouplingFieldDouble_substractInPlaceDM_3] +} + +void CppExample_MEDCouplingFieldDouble_changeUnderlyingMesh() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_changeUnderlyingMesh_1] + const double coords1[4] = {0.,1.,2.,3.}; + const double coords2[4] = {2.,1.,0.,3.}; // #0 <==> #2 + // mesh 1 + MEDCouplingAutoRefCountObjectPtr mesh1 = MEDCouplingUMesh::New(); + MEDCouplingAutoRefCountObjectPtr coordsArr = DataArrayDouble::New(); + coordsArr->useExternalArrayWithRWAccess( coords1, 4, 1 ); + mesh1->setCoords(coordsArr); + mesh1->setMeshDimension(0); + mesh1->allocateCells(0); + mesh1->finishInsertingCells(); + // mesh 2 + MEDCouplingAutoRefCountObjectPtr mesh2 = + (MEDCouplingUMesh*) mesh1->deepCpy(); + mesh2->getCoords()->useExternalArrayWithRWAccess( coords2, 4, 1 ); + //! [CppSnippet_MEDCouplingFieldDouble_changeUnderlyingMesh_1] + //! [CppSnippet_MEDCouplingFieldDouble_changeUnderlyingMesh_2] + MEDCouplingAutoRefCountObjectPtr field = + mesh1->fillFromAnalytic( ParaMEDMEM::ON_NODES,1,"x"); // field values == coords1 + const double levOfCheck = 10; // nodes can be permuted + field->changeUnderlyingMesh( mesh2, levOfCheck, 1e-13, 0 ); // values #0 and #2 must swap + CPPUNIT_ASSERT( std::equal( coords2, coords2+4, field->getArray()->getConstPointer() )); + //! [CppSnippet_MEDCouplingFieldDouble_changeUnderlyingMesh_2] +} + +void CppExample_MEDCouplingFieldDouble_applyFunc_same_nb_comp() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_applyFunc_same_nb_comp_1] + const double v[4] = {1.,2., 3.,4.}; + MEDCouplingAutoRefCountObjectPtr array = DataArrayDouble::New(); + array->useExternalArrayWithRWAccess( v, 2, 2 ); // 2 tuples per 2 components + MEDCouplingAutoRefCountObjectPtr field = + MEDCouplingFieldDouble::New( ParaMEDMEM::ON_CELLS ); + field->setArray( array ); + const char func[] = "IVec * v + JVec * v*v + 10"; + field->applyFunc( func ); + CPPUNIT_ASSERT( field->getNumberOfComponents() == 2 ); // 2 components remains + //! [CppSnippet_MEDCouplingFieldDouble_applyFunc_same_nb_comp_1] + //! [CppSnippet_MEDCouplingFieldDouble_applyFunc_same_nb_comp_2] + const double* v2 = field->getArray()->getConstPointer(); + CPPUNIT_ASSERT_DOUBLES_EQUAL( v2[0], 10 + v[0], 13 ); // "10 + IVec * v" + CPPUNIT_ASSERT_DOUBLES_EQUAL( v2[1], 10 + v[1]*v[1], 13 ); // "10 + JVec * v*v" + CPPUNIT_ASSERT_DOUBLES_EQUAL( v2[2], 10 + v[2], 13 ); // "10 + IVec * v" + CPPUNIT_ASSERT_DOUBLES_EQUAL( v2[3], 10 + v[3]*v[3], 13 ); // "10 + JVec * v*v" + //! [CppSnippet_MEDCouplingFieldDouble_applyFunc_same_nb_comp_2] +} + +void CppExample_MEDCouplingFieldDouble_applyFunc3() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_applyFunc3_1] + // create a 2D vector field + const double values[4] = {1.,1., 2.,1.}; + MEDCouplingAutoRefCountObjectPtr array = DataArrayDouble::New(); + array->useExternalArrayWithRWAccess( values, 2, 2 ); // 2 tuples per 2 components + MEDCouplingAutoRefCountObjectPtr field = + MEDCouplingFieldDouble::New( ParaMEDMEM::ON_CELLS ); + field->setArray( array ); + // transform the field to a 3D vector field + const char func[] = "IVec * b + JVec * a + KVec * sqrt( a*a + b*b ) + 10"; + const char* varNames[2] = { "a", "b" }; // names used to refer to X and Y components + std::vector varNamesVec( varNames, varNames+2 ); + field->applyFunc3( 3, varNamesVec, func ); // require 3 components + CPPUNIT_ASSERT( field->getNumberOfComponents() == 3 ); // 3 components as required + //! [CppSnippet_MEDCouplingFieldDouble_applyFunc3_1] + //! [CppSnippet_MEDCouplingFieldDouble_applyFunc3_2] + double vec1[3]; // vector #1 + field->getArray()->getTuple( 1, vec1 ); + const double a = values[2], b = values[3]; // initial components of the vector #1 + CPPUNIT_ASSERT_DOUBLES_EQUAL( vec1[0], 10 + b, 13 ); // "10 + IVec * b" + CPPUNIT_ASSERT_DOUBLES_EQUAL( vec1[1], 10 + a, 13 ); // "10 + JVec * a" + CPPUNIT_ASSERT_DOUBLES_EQUAL( vec1[2], 10 + sqrt(a*a+b*b), 13 ); // "10 + KVec * sqrt( a*a + b*b )" + //! [CppSnippet_MEDCouplingFieldDouble_applyFunc3_2] +} + +void CppExample_MEDCouplingFieldDouble_applyFunc2() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_applyFunc2_1] + // create a 2D vector field + const double values[4] = {1.,1., 2.,1.}; + MEDCouplingAutoRefCountObjectPtr array = DataArrayDouble::New(); + array->useExternalArrayWithRWAccess( values, 2, 2 ); // 2 tuples per 2 components + array->setInfoOnComponent(0,"a"); // name used to refer to X component within a function + array->setInfoOnComponent(1,"b"); // name used to refer to Y component within a function + MEDCouplingAutoRefCountObjectPtr field = + MEDCouplingFieldDouble::New( ParaMEDMEM::ON_CELLS ); + field->setArray( array ); + // transform the field to a 3D vector field + const char func[] = "IVec * b + JVec * a + KVec * sqrt( a*a + b*b ) + 10"; + field->applyFunc2( 3, func ); // require 3 components + CPPUNIT_ASSERT( field->getNumberOfComponents() == 3 ); // 3 components as required + //! [CppSnippet_MEDCouplingFieldDouble_applyFunc2_1] + //! [CppSnippet_MEDCouplingFieldDouble_applyFunc2_2] + double vec1[3]; // vector #1 + field->getArray()->getTuple( 1, vec1 ); + const double a = values[2], b = values[3]; // initial components of the vector #1 + CPPUNIT_ASSERT_DOUBLES_EQUAL( vec1[0], 10 + b, 13 ); // "10 + IVec * b" + CPPUNIT_ASSERT_DOUBLES_EQUAL( vec1[1], 10 + a, 13 ); // "10 + JVec * a" + CPPUNIT_ASSERT_DOUBLES_EQUAL( vec1[2], 10 + sqrt(a*a+b*b), 13 ); // "10 + KVec * sqrt( a*a + b*b )" + //! [CppSnippet_MEDCouplingFieldDouble_applyFunc2_2] +} + +void CppExample_MEDCouplingFieldDouble_applyFunc() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_applyFunc_1] + // create a 2D vector field + const double values[4] = {1.,1., 2.,1.}; + MEDCouplingAutoRefCountObjectPtr array = DataArrayDouble::New(); + array->useExternalArrayWithRWAccess( values, 2, 2 ); // 2 tuples per 2 components + MEDCouplingAutoRefCountObjectPtr field = + MEDCouplingFieldDouble::New( ParaMEDMEM::ON_CELLS ); + field->setArray( array ); + // transform the field to a 3D vector field + const char func[] = "IVec * b + JVec * a + KVec * sqrt( a*a + b*b ) + 10"; + field->applyFunc( 3, func ); // require 3 components + CPPUNIT_ASSERT( field->getNumberOfComponents() == 3 ); // 3 components as required + //! [CppSnippet_MEDCouplingFieldDouble_applyFunc_1] + //! [CppSnippet_MEDCouplingFieldDouble_applyFunc_2] + double vec1[3]; // vector #1 + field->getArray()->getTuple( 1, vec1 ); + const double a = values[2], b = values[3]; // initial components of the vector #1 + CPPUNIT_ASSERT_DOUBLES_EQUAL( vec1[0], 10 + b, 13 ); // "10 + IVec * b" + CPPUNIT_ASSERT_DOUBLES_EQUAL( vec1[1], 10 + a, 13 ); // "10 + JVec * a" + CPPUNIT_ASSERT_DOUBLES_EQUAL( vec1[2], 10 + sqrt(a*a+b*b), 13 ); // "10 + KVec * sqrt( a*a + b*b )" + //! [CppSnippet_MEDCouplingFieldDouble_applyFunc_2] +} + +void CppExample_MEDCouplingFieldDouble_applyFunc_val() +{ + using namespace ParaMEDMEM; + //! [Snippet_MEDCouplingFieldDouble_applyFunc_val_1] + // mesh + const double coords[4] = {0.,2.,4.}; + MEDCouplingAutoRefCountObjectPtr coordsArr = DataArrayDouble::New(); + coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 ); + MEDCouplingAutoRefCountObjectPtr mesh = MEDCouplingCMesh::New(); + mesh->setCoords(coordsArr,coordsArr); // mesh becomes a 2D structured mesh + // field + MEDCouplingAutoRefCountObjectPtr field = + MEDCouplingFieldDouble::New( ParaMEDMEM::ON_CELLS ); + field->setMesh( mesh ); + field->fillFromAnalytic(2,"IVec * x + JVec * y"); // 2 components + //! [Snippet_MEDCouplingFieldDouble_applyFunc_val_1] + //! [Snippet_MEDCouplingFieldDouble_applyFunc_val_2] + const double newValue = 7.; + field->applyFunc( 3, newValue ); // # 3 components are required + CPPUNIT_ASSERT( field->getIJ(1,0) == newValue ); // a value is as expected + CPPUNIT_ASSERT( field->getNumberOfComponents() == 3 ); + CPPUNIT_ASSERT( field->getNumberOfTuples() == mesh->getNumberOfCells() ); + //! [Snippet_MEDCouplingFieldDouble_applyFunc_val_2] +} + +void CppExample_MEDCouplingFieldDouble_fillFromAnalytic3() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic3_1] + const double coords[4] = {0.,2.,4.,6.}; // 6. is not used + MEDCouplingAutoRefCountObjectPtr x = DataArrayDouble::New(); + x->useExternalArrayWithRWAccess( coords, 3, 1 ); + MEDCouplingAutoRefCountObjectPtr y = DataArrayDouble::New(); + y->useExternalArrayWithRWAccess( coords, 2, 1 ); + MEDCouplingAutoRefCountObjectPtr mesh=MEDCouplingCMesh::New(); + mesh->setCoords(x,y); + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic3_1] + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic3_2] + MEDCouplingAutoRefCountObjectPtr field = + MEDCouplingFieldDouble::New( ParaMEDMEM::ON_CELLS ); + field->setMesh( mesh ); + const char func[] = "IVec * b + JVec * a + KVec * sqrt( a*a + b*b ) + 10"; + const char* varNames[2] = { "a", "b" }; // names used to refer to X and Y coord components + std::vector varNamesVec( varNames, varNames+2 ); + field->fillFromAnalytic3( 3, varNamesVec, func ); + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic3_2] + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic3_3] + double val1[3]; // a value (vector) of the cell #1 + CPPUNIT_ASSERT( field->getNumberOfComponents() == 3 ); // 3 components in the field + field->getArray()->getTuple( 1, val1 ); + // + MEDCouplingAutoRefCountObjectPtr bc = + mesh->getBarycenterAndOwner(); // func is applied to barycenters of cells + double bc1[2]; // coordinates of the second point + bc->getTuple( 1, bc1 ); + // + double dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[0], 10 + bc1[1], 13 ); // "10 + IVec * b" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[1], 10 + bc1[0], 13 ); // "10 + JVec * a" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[2], 10 + dist , 13 ); // "10 + KVec * sqrt( a*a + b*b )" + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic3_3] +} + +void CppExample_MEDCouplingFieldDouble_fillFromAnalytic2() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic2_1] + const double coords[4] = {0.,2.,4.}; + MEDCouplingAutoRefCountObjectPtr x = DataArrayDouble::New(); + x->useExternalArrayWithRWAccess( coords, 3, 1 ); + MEDCouplingAutoRefCountObjectPtr y = DataArrayDouble::New(); + y->useExternalArrayWithRWAccess( coords, 2, 1 ); + x->setInfoOnComponent(0,"a"); // name used to refer to X coordinate within a function + y->setInfoOnComponent(0,"b"); // name used to refer to Y coordinate within a function + MEDCouplingAutoRefCountObjectPtr mesh=MEDCouplingCMesh::New(); + mesh->setCoords(x,y); + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic2_1] + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic2_2] + MEDCouplingAutoRefCountObjectPtr field = + MEDCouplingFieldDouble::New( ParaMEDMEM::ON_CELLS ); + field->setMesh( mesh ); + const char func[] = "IVec * b + JVec * a + KVec * sqrt( a*a + b*b ) + 10"; + field->fillFromAnalytic( 3, func ); + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic2_2] + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic2_3] + double val1[3]; // a value (vector) of the cell #1 + CPPUNIT_ASSERT( field->getNumberOfComponents() == 3 ); // 3 components in the field + field->getArray()->getTuple( 1, val1 ); + // + MEDCouplingAutoRefCountObjectPtr bc = + mesh->getBarycenterAndOwner(); // func is applied to barycenters of cells + double bc1[2]; // coordinates of the second point + bc->getTuple( 1, bc1 ); + // + double dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[0], 10 + bc1[1], 13 ); // "10 + IVec * b" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[1], 10 + bc1[0], 13 ); // "10 + JVec * a" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[2], 10 + dist , 13 ); // "10 + KVec * sqrt( a*a + b*b )" + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic2_3] +} + +void CppExample_MEDCouplingFieldDouble_fillFromAnalytic() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic_1] + const double coords[3] = {0.,2.,4}; + MEDCouplingAutoRefCountObjectPtr x = DataArrayDouble::New(); + x->useExternalArrayWithRWAccess( coords, 3, 1 ); + MEDCouplingAutoRefCountObjectPtr y = DataArrayDouble::New(); + y->useExternalArrayWithRWAccess( coords, 2, 1 ); + MEDCouplingAutoRefCountObjectPtr mesh=MEDCouplingCMesh::New(); + mesh->setCoords(x,y); + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic_1] + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic_2] + const char func[] = "IVec * b + JVec * a + KVec * sqrt( a*a + b*b ) + 10"; + MEDCouplingAutoRefCountObjectPtr field = + MEDCouplingFieldDouble::New( ParaMEDMEM::ON_CELLS ); + field->setMesh( mesh ); + field->fillFromAnalytic( 3, func ); + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic_2] + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic_3] + double val1[3]; // a value (vector) of the cell #1 + CPPUNIT_ASSERT( field->getNumberOfComponents() == 3 ); // 3 components in the field + field->getArray()->getTuple( 1, val1 ); + // + MEDCouplingAutoRefCountObjectPtr bc = + mesh->getBarycenterAndOwner(); // func is applied to barycenters of cells + double bc1[2]; // coordinates of the second point + bc->getTuple( 1, bc1 ); + // + double dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[0], 10 + bc1[1], 13 ); // "10 + IVec * b" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[1], 10 + bc1[0], 13 ); // "10 + JVec * a" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[2], 10 + dist , 13 ); // "10 + KVec * sqrt( a*a + b*b )" + //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic_3] +} + +//! [Snippet_MEDCouplingFieldDouble_fillFromAnalytic_c_func_0] +bool getNewValue(const double *pos, double *res) +{ + res[0] = pos[0]; + res[1] = pos[1]; + res[2] = sqrt( pos[0]*pos[0] + pos[1]*pos[1] ); + return true; +} +//! [Snippet_MEDCouplingFieldDouble_fillFromAnalytic_c_func_0] + +void CppExample_MEDCouplingFieldDouble_fillFromAnalytic_c_func() +{ + using namespace ParaMEDMEM; + //! [Snippet_MEDCouplingFieldDouble_fillFromAnalytic_c_func_1] + // mesh + const double coords[4] = {0.,2.,4.}; + MEDCouplingAutoRefCountObjectPtr coordsArr = DataArrayDouble::New(); + coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 ); + MEDCouplingAutoRefCountObjectPtr mesh = MEDCouplingCMesh::New(); + mesh->setCoords(coordsArr,coordsArr); // mesh becomes a 2D structured mesh + // field + MEDCouplingAutoRefCountObjectPtr field = + MEDCouplingFieldDouble::New( ParaMEDMEM::ON_CELLS ); + field->setMesh( mesh ); + field->fillFromAnalytic( 3, &getNewValue ); // 3 components are required + CPPUNIT_ASSERT( field->getNumberOfComponents() == 3 ); + CPPUNIT_ASSERT( field->getNumberOfTuples() == mesh->getNumberOfCells() ); + //! [Snippet_MEDCouplingFieldDouble_fillFromAnalytic_c_func_1] +} + +void CppExample_MEDCouplingFieldDouble_applyFunc_c_func() +{ + using namespace ParaMEDMEM; + //! [Snippet_MEDCouplingFieldDouble_applyFunc_c_func_1] + // mesh + const double coords[4] = {0.,2.,4.}; + MEDCouplingAutoRefCountObjectPtr coordsArr = DataArrayDouble::New(); + coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 ); + MEDCouplingAutoRefCountObjectPtr mesh = MEDCouplingCMesh::New(); + mesh->setCoords(coordsArr,coordsArr); // mesh becomes a 2D structured mesh + // field + MEDCouplingAutoRefCountObjectPtr field = + MEDCouplingFieldDouble::New( ParaMEDMEM::ON_CELLS ); + field->setMesh( mesh ); + MEDCouplingAutoRefCountObjectPtr bc = mesh->getBarycenterAndOwner(); + field->setArray( bc ); // 2 components here as the mesh is 2D + //! [Snippet_MEDCouplingFieldDouble_applyFunc_c_func_1] + //! [Snippet_MEDCouplingFieldDouble_applyFunc_c_func_2] + field->applyFunc( 3, &getNewValue ); // 3 components are required + CPPUNIT_ASSERT( field->getNumberOfComponents() == 3 ); + CPPUNIT_ASSERT( field->getNumberOfTuples() == mesh->getNumberOfCells() ); + //! [Snippet_MEDCouplingFieldDouble_applyFunc_c_func_2] +} + +void CppExample_MEDCouplingFieldDouble_getValueOn_time() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_getValueOn_time_1] + const double coords[4] = {0.,2.,4.}; + MEDCouplingAutoRefCountObjectPtr coordsArr = DataArrayDouble::New(); + coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 ); + MEDCouplingAutoRefCountObjectPtr mesh = MEDCouplingCMesh::New(); + mesh->setCoords(coordsArr,coordsArr); + //! [CppSnippet_MEDCouplingFieldDouble_getValueOn_time_1] + //! [CppSnippet_MEDCouplingFieldDouble_getValueOn_time_2] + MEDCouplingAutoRefCountObjectPtr field = + MEDCouplingFieldDouble::New( ParaMEDMEM::ON_CELLS, ParaMEDMEM::LINEAR_TIME ); + field->setMesh( mesh ); + field->fillFromAnalytic( 1,"10"); // all values == 10. + MEDCouplingAutoRefCountObjectPtr array2 = + DataArrayDouble::Add( field->getArray(), field->getArray() ); // == 2 * field->getArray() + field->setEndArray( array2 ); // all values == 20. + const double time1 = 1.1, time2 = 22.; + field->setStartTime( time1, 0, 0 ); + field->setEndTime ( time2, 0, 0 ); + //! [CppSnippet_MEDCouplingFieldDouble_getValueOn_time_2] + //! [CppSnippet_MEDCouplingFieldDouble_getValueOn_time_3] + const double pos[2] = { 1., 1. }; // we are in 2D space + double value[1]; // the field is scalar <-> 1 component + field->getValueOn( pos, 0.5*( time1 + time2 ), value ); + CPPUNIT_ASSERT( fabs( value[0] - 0.5*( 10. + 20. )) < 1e-13 ); + //! [CppSnippet_MEDCouplingFieldDouble_getValueOn_time_3] +} + +void CppExample_MEDCouplingFieldDouble_getValueOnMulti() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_getValueOnMulti_1] + const double coords[4] = {0.,2.,4.}; + MEDCouplingAutoRefCountObjectPtr coordsArr = DataArrayDouble::New(); + coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 ); + MEDCouplingAutoRefCountObjectPtr mesh = MEDCouplingCMesh::New(); + mesh->setCoords(coordsArr,coordsArr); + MEDCouplingAutoRefCountObjectPtr field = + mesh->fillFromAnalytic( ParaMEDMEM::ON_CELLS,1,"x+y"); + //! [CppSnippet_MEDCouplingFieldDouble_getValueOnMulti_1] + //! [CppSnippet_MEDCouplingFieldDouble_getValueOnMulti_2] + // field values are located at cell barycenters + MEDCouplingAutoRefCountObjectPtr bc = mesh->getBarycenterAndOwner(); + MEDCouplingAutoRefCountObjectPtr valArray = + field->getValueOnMulti( bc->getConstPointer(), bc->getNumberOfTuples() ); + CPPUNIT_ASSERT( valArray->isEqual( * field->getArray(), 1e-13 )); + //! [CppSnippet_MEDCouplingFieldDouble_getValueOnMulti_2] +} + +void CppExample_MEDCouplingFieldDouble_getValueOn() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_getValueOn_1] + const double coords[4] = {0.,2.,4.}; + MEDCouplingAutoRefCountObjectPtr coordsArr = DataArrayDouble::New(); + coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 ); + MEDCouplingAutoRefCountObjectPtr mesh = MEDCouplingCMesh::New(); + mesh->setCoords(coordsArr,coordsArr); + MEDCouplingAutoRefCountObjectPtr field = + mesh->fillFromAnalytic( ParaMEDMEM::ON_CELLS,1,"x+y"); + //! [CppSnippet_MEDCouplingFieldDouble_getValueOn_1] + //! [CppSnippet_MEDCouplingFieldDouble_getValueOn_2] + // field values are located at cell barycenters + MEDCouplingAutoRefCountObjectPtr bc = mesh->getBarycenterAndOwner(); + std::vector vals( field->getNumberOfTuples() ); // array to collect values returned by getValueOn() + double cellBC[2]; // we are in 2D space + for ( int i = 0; i < bc->getNumberOfTuples(); ++i ) + { + bc->getTuple( i, cellBC ); + field->getValueOn( cellBC, & vals[i] ); + } + CPPUNIT_ASSERT( std::equal( vals.begin(), vals.end(), field->getArray()->getConstPointer() )); + //! [CppSnippet_MEDCouplingFieldDouble_getValueOn_2] +} + +void CppExample_MEDCouplingFieldDouble_getValueOnPos() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_getValueOnPos_1] + const double coords[4] = {0.,2.,4.}; + MEDCouplingAutoRefCountObjectPtr coordsArr = DataArrayDouble::New(); + coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 ); + MEDCouplingAutoRefCountObjectPtr mesh = MEDCouplingCMesh::New(); + mesh->setCoords(coordsArr,coordsArr); + MEDCouplingAutoRefCountObjectPtr field = + mesh->fillFromAnalytic( ParaMEDMEM::ON_CELLS,1,"x+y"); + //! [CppSnippet_MEDCouplingFieldDouble_getValueOnPos_1] + //! [CppSnippet_MEDCouplingFieldDouble_getValueOnPos_2] + double val11[1]; // 1 == field->getNumberOfComponents() + field->getValueOnPos( 1,1,-1, val11 ); + // field values are located at cell barycenters + MEDCouplingAutoRefCountObjectPtr bc = mesh->getBarycenterAndOwner(); + CPPUNIT_ASSERT( val11[0] == bc->getIJ(3,0) + bc->getIJ(3,1) ); + //! [CppSnippet_MEDCouplingFieldDouble_getValueOnPos_2] +} + +void CppExample_MEDCouplingFieldDouble_renumberNodes() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_renumberNodes_1] + const double coords[4] = {0.,2.,4.}; + MEDCouplingAutoRefCountObjectPtr coordsArr = DataArrayDouble::New(); + coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 ); + MEDCouplingAutoRefCountObjectPtr cmesh = MEDCouplingCMesh::New(); + cmesh->setCoords(coordsArr,coordsArr); + MEDCouplingAutoRefCountObjectPtr mesh = cmesh->buildUnstructured(); + //! [CppSnippet_MEDCouplingFieldDouble_renumberNodes_1] + //! [CppSnippet_MEDCouplingFieldDouble_renumberNodes_2] + MEDCouplingAutoRefCountObjectPtr field = + mesh->fillFromAnalytic( ParaMEDMEM::ON_NODES,2,"IVec*x+JVec*y"); + const DataArrayDouble* values = field->getArray(); + const DataArrayDouble* nodeCoords = mesh->getCoords(); + CPPUNIT_ASSERT( values->isEqualWithoutConsideringStr( *nodeCoords, 1e-13 )); + //! [CppSnippet_MEDCouplingFieldDouble_renumberNodes_2] + //! [CppSnippet_MEDCouplingFieldDouble_renumberNodes_3] + const int renumber[9] = { 8, 7, 6, 5, 4, 3, 2, 1, 0 }; + field->renumberNodes(renumber,false); + const MEDCouplingMesh* mesh2 = field->getMesh(); // field now refers to another mesh + values = field->getArray(); + nodeCoords = ((MEDCouplingUMesh*)mesh2)->getCoords(); + CPPUNIT_ASSERT( values->isEqualWithoutConsideringStr( *nodeCoords, 1e-13 )); + //! [CppSnippet_MEDCouplingFieldDouble_renumberNodes_3] +} + +void CppExample_MEDCouplingFieldDouble_renumberCells() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_renumberCells_1] + const double coords[4] = {0.,2.,4.}; + MEDCouplingAutoRefCountObjectPtr coordsArr = DataArrayDouble::New(); + coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 ); + MEDCouplingAutoRefCountObjectPtr cmesh = MEDCouplingCMesh::New(); + cmesh->setCoords(coordsArr,coordsArr); + MEDCouplingAutoRefCountObjectPtr mesh = cmesh->buildUnstructured(); + //! [CppSnippet_MEDCouplingFieldDouble_renumberCells_1] + //! [CppSnippet_MEDCouplingFieldDouble_renumberCells_2] + MEDCouplingAutoRefCountObjectPtr field = + mesh->fillFromAnalytic( ParaMEDMEM::ON_CELLS,2,"IVec*x+JVec*y"); + const DataArrayDouble* values = field->getArray(); + MEDCouplingAutoRefCountObjectPtr bc = mesh->getBarycenterAndOwner(); + CPPUNIT_ASSERT( values->isEqualWithoutConsideringStr( *bc, 1e-13 )); + //! [CppSnippet_MEDCouplingFieldDouble_renumberCells_2] + //! [CppSnippet_MEDCouplingFieldDouble_renumberCells_3] + const int renumber[4] = { 3, 2, 1, 0 }; + field->renumberCells(renumber,false); + const MEDCouplingMesh* mesh2 = field->getMesh(); // field now refers to another mesh + values = field->getArray(); + bc = mesh2->getBarycenterAndOwner(); + CPPUNIT_ASSERT( values->isEqualWithoutConsideringStr( *bc, 1e-13 )); + //! [CppSnippet_MEDCouplingFieldDouble_renumberCells_3] +} + +void CppExample_MEDCouplingFieldDouble_buildNewTimeReprFromThis() +{ + using namespace ParaMEDMEM; + //! [CppSnippet_MEDCouplingFieldDouble_buildNewTimeReprFromThis_1] + const double coords[4] = {0.,2.,4.}; + MEDCouplingAutoRefCountObjectPtr coordsArr = DataArrayDouble::New(); + coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 ); + MEDCouplingAutoRefCountObjectPtr mesh = MEDCouplingCMesh::New(); + mesh->setCoords(coordsArr,coordsArr); + MEDCouplingAutoRefCountObjectPtr field1 = + mesh->fillFromAnalytic( ParaMEDMEM::ON_NODES,1,"x+y"); + CPPUNIT_ASSERT( field1->getTimeDiscretization() == ParaMEDMEM::ONE_TIME ); + //! [CppSnippet_MEDCouplingFieldDouble_buildNewTimeReprFromThis_1] + //! [CppSnippet_MEDCouplingFieldDouble_buildNewTimeReprFromThis_2] + MEDCouplingAutoRefCountObjectPtr field2 = + field1->buildNewTimeReprFromThis( ParaMEDMEM::NO_TIME, false ); + CPPUNIT_ASSERT( field2->getTimeDiscretization() == ParaMEDMEM::NO_TIME ); + //! [CppSnippet_MEDCouplingFieldDouble_buildNewTimeReprFromThis_2] +} + +void CppExample_MEDCouplingMesh_fillFromAnalytic3() { using namespace ParaMEDMEM; //! [CppSnippet_MEDCouplingMesh_fillFromAnalytic3_1] @@ -47,9 +669,9 @@ void CppExample_MEDCouplingPointSet_fillFromAnalytic3() mesh->fillFromAnalytic3( ParaMEDMEM::ON_CELLS, 3, varNamesVec, func ); //! [CppSnippet_MEDCouplingMesh_fillFromAnalytic3_2] //! [CppSnippet_MEDCouplingMesh_fillFromAnalytic3_3] - double vals1[3]; // values of the cell #1 + double val1[3]; // a value (vector) of the cell #1 CPPUNIT_ASSERT( field->getNumberOfComponents() == 3 ); // 3 components in the field - field->getArray()->getTuple( 1, vals1 ); + field->getArray()->getTuple( 1, val1 ); // MEDCouplingAutoRefCountObjectPtr bc = mesh->getBarycenterAndOwner(); // func is applied to barycenters of cells @@ -57,13 +679,13 @@ void CppExample_MEDCouplingPointSet_fillFromAnalytic3() bc->getTuple( 1, bc1 ); // double dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )" - CPPUNIT_ASSERT_DOUBLES_EQUAL( vals1[0], 10 + bc1[1], 13 ); // "10 + IVec * b" - CPPUNIT_ASSERT_DOUBLES_EQUAL( vals1[1], 10 + bc1[0], 13 ); // "10 + JVec * a" - CPPUNIT_ASSERT_DOUBLES_EQUAL( vals1[2], 10 + dist , 13 ); // "10 + KVec * sqrt( a*a + b*b )" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[0], 10 + bc1[1], 13 ); // "10 + IVec * b" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[1], 10 + bc1[0], 13 ); // "10 + JVec * a" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[2], 10 + dist , 13 ); // "10 + KVec * sqrt( a*a + b*b )" //! [CppSnippet_MEDCouplingMesh_fillFromAnalytic3_3] } -void CppExample_MEDCouplingPointSet_fillFromAnalytic2() +void CppExample_MEDCouplingMesh_fillFromAnalytic2() { using namespace ParaMEDMEM; //! [CppSnippet_MEDCouplingMesh_fillFromAnalytic2_1] @@ -83,9 +705,9 @@ void CppExample_MEDCouplingPointSet_fillFromAnalytic2() mesh->fillFromAnalytic2( ParaMEDMEM::ON_CELLS, 3, func ); //! [CppSnippet_MEDCouplingMesh_fillFromAnalytic2_2] //! [CppSnippet_MEDCouplingMesh_fillFromAnalytic2_3] - double vals1[3]; // values of the cell #1 + double val1[3]; // a value (vector) of the cell #1 CPPUNIT_ASSERT( field->getNumberOfComponents() == 3 ); // 3 components in the field - field->getArray()->getTuple( 1, vals1 ); + field->getArray()->getTuple( 1, val1 ); // MEDCouplingAutoRefCountObjectPtr bc = mesh->getBarycenterAndOwner(); // func is applied to barycenters of cells @@ -93,13 +715,13 @@ void CppExample_MEDCouplingPointSet_fillFromAnalytic2() bc->getTuple( 1, bc1 ); // double dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )" - CPPUNIT_ASSERT_DOUBLES_EQUAL( vals1[0], 10 + bc1[1], 13 ); // "10 + IVec * b" - CPPUNIT_ASSERT_DOUBLES_EQUAL( vals1[1], 10 + bc1[0], 13 ); // "10 + JVec * a" - CPPUNIT_ASSERT_DOUBLES_EQUAL( vals1[2], 10 + dist , 13 ); // "10 + KVec * sqrt( a*a + b*b )" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[0], 10 + bc1[1], 13 ); // "10 + IVec * b" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[1], 10 + bc1[0], 13 ); // "10 + JVec * a" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[2], 10 + dist , 13 ); // "10 + KVec * sqrt( a*a + b*b )" //! [CppSnippet_MEDCouplingMesh_fillFromAnalytic2_3] } -void CppExample_MEDCouplingPointSet_fillFromAnalytic() +void CppExample_MEDCouplingMesh_fillFromAnalytic() { using namespace ParaMEDMEM; //! [CppSnippet_MEDCouplingMesh_fillFromAnalytic_1] @@ -117,9 +739,9 @@ void CppExample_MEDCouplingPointSet_fillFromAnalytic() mesh->fillFromAnalytic( ParaMEDMEM::ON_CELLS, 3, func ); //! [CppSnippet_MEDCouplingMesh_fillFromAnalytic_2] //! [CppSnippet_MEDCouplingMesh_fillFromAnalytic_3] - double vals1[3]; // values of the cell #1 + double val1[3]; // a value (vector) of the cell #1 CPPUNIT_ASSERT( field->getNumberOfComponents() == 3 ); // 3 components in the field - field->getArray()->getTuple( 1, vals1 ); + field->getArray()->getTuple( 1, val1 ); // MEDCouplingAutoRefCountObjectPtr bc = mesh->getBarycenterAndOwner(); // func is applied to barycenters of cells @@ -127,13 +749,13 @@ void CppExample_MEDCouplingPointSet_fillFromAnalytic() bc->getTuple( 1, bc1 ); // double dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )" - CPPUNIT_ASSERT_DOUBLES_EQUAL( vals1[0], 10 + bc1[1], 13 ); // "10 + IVec * b" - CPPUNIT_ASSERT_DOUBLES_EQUAL( vals1[1], 10 + bc1[0], 13 ); // "10 + JVec * a" - CPPUNIT_ASSERT_DOUBLES_EQUAL( vals1[2], 10 + dist , 13 ); // "10 + KVec * sqrt( a*a + b*b )" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[0], 10 + bc1[1], 13 ); // "10 + IVec * b" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[1], 10 + bc1[0], 13 ); // "10 + JVec * a" + CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[2], 10 + dist , 13 ); // "10 + KVec * sqrt( a*a + b*b )" //! [CppSnippet_MEDCouplingMesh_fillFromAnalytic_3] } -void CppExample_MEDCouplingPointSet_getCoordsAt() +void CppExample_MEDCouplingCMesh_getCoordsAt() { using namespace ParaMEDMEM; //! [CppSnippet_MEDCouplingCMesh_getCoordsAt_1] @@ -1876,7 +2498,32 @@ void CppSnippetFieldDoubleBuild4() int main(int argc, char *argv[]) { - CppExample_MEDCouplingPointSet_getCoordsAt(); + CppExample_MEDCouplingFieldDouble_WriteVTK(); + CppExample_MEDCouplingFieldDouble_MaxFields(); + CppExample_MEDCouplingFieldDouble_MergeFields(); + CppExample_MEDCouplingFieldDouble_substractInPlaceDM(); + CppExample_MEDCouplingFieldDouble_changeUnderlyingMesh(); + CppExample_MEDCouplingFieldDouble_applyFunc_same_nb_comp(); + CppExample_MEDCouplingFieldDouble_applyFunc3(); + CppExample_MEDCouplingFieldDouble_applyFunc2(); + CppExample_MEDCouplingFieldDouble_applyFunc(); + CppExample_MEDCouplingFieldDouble_applyFunc_val(); + CppExample_MEDCouplingFieldDouble_fillFromAnalytic3(); + CppExample_MEDCouplingFieldDouble_fillFromAnalytic2(); + CppExample_MEDCouplingFieldDouble_fillFromAnalytic(); + CppExample_MEDCouplingFieldDouble_fillFromAnalytic_c_func(); + CppExample_MEDCouplingFieldDouble_applyFunc_c_func(); + CppExample_MEDCouplingFieldDouble_getValueOn_time(); + CppExample_MEDCouplingFieldDouble_getValueOnMulti(); + CppExample_MEDCouplingFieldDouble_getValueOn(); + CppExample_MEDCouplingFieldDouble_getValueOnPos(); + CppExample_MEDCouplingFieldDouble_renumberNodes(); + CppExample_MEDCouplingFieldDouble_renumberCells(); + CppExample_MEDCouplingFieldDouble_buildNewTimeReprFromThis(); + CppExample_MEDCouplingMesh_fillFromAnalytic3(); + CppExample_MEDCouplingMesh_fillFromAnalytic2(); + CppExample_MEDCouplingMesh_fillFromAnalytic(); + CppExample_MEDCouplingCMesh_getCoordsAt(); CppExample_MEDCouplingUMesh_areCellsIncludedIn(); CppExample_MEDCouplingUMesh_findAndCorrectBadOriented3DExtrudedCells(); CppExample_MEDCouplingUMesh_arePolyhedronsNotCorrectlyOriented(); @@ -1927,5 +2574,6 @@ int main(int argc, char *argv[]) CppSnippetFieldDoubleBuild2(); CppSnippetFieldDoubleBuild3(); CppSnippetFieldDoubleBuild4(); + return 0; } diff --git a/src/MEDCouplingCorba_Swig/CMakeLists.txt b/src/MEDCouplingCorba_Swig/CMakeLists.txt index 67482021e..2aa8561b8 100644 --- a/src/MEDCouplingCorba_Swig/CMakeLists.txt +++ b/src/MEDCouplingCorba_Swig/CMakeLists.txt @@ -26,6 +26,9 @@ INCLUDE(${SWIG_USE_FILE}) SET_SOURCE_FILES_PROPERTIES(MEDCouplingCorba.i PROPERTIES CPLUSPLUS ON) SET_SOURCE_FILES_PROPERTIES(MEDCouplingCorba.i PROPERTIES SWIG_DEFINITIONS "-shadow") +IF(NUMPY_STATUS) + SET(SWIG_MODULE_MEDCouplingCorba_EXTRA_FLAGS -DWITH_NUMPY) +ENDIF(NUMPY_STATUS) SET(MEDCouplingCorba_SWIG_DPYS_FILES MEDCouplingCorbaTypemaps.i) @@ -51,7 +54,7 @@ SET (SWIG_MODULE_MEDCouplingCorba_EXTRA_DEPS ${MEDCouplingCorba_SWIG_DPYS_FILES} SWIG_ADD_MODULE(MEDCouplingCorba python MEDCouplingCorba.i) SWIG_LINK_LIBRARIES(MEDCouplingCorba ${PYTHON_LIBS} medcouplingcorba ${PLATFORM_LIBS}) -SET_TARGET_PROPERTIES(_MEDCouplingCorba PROPERTIES COMPILE_FLAGS "${OMNIORB_DEFINITIONS} ${PLATFORM_DEFINITIONS}") +SET_TARGET_PROPERTIES(_MEDCouplingCorba PROPERTIES COMPILE_FLAGS "${OMNIORB_DEFINITIONS} ${PLATFORM_DEFINITIONS} ${PYTHON_DEFINITIONS}") IF(${MACHINE} STREQUAL WINDOWS) SET_TARGET_PROPERTIES(_MEDCouplingCorba PROPERTIES DEBUG_OUTPUT_NAME _MEDCouplingCorba_d) ENDIF(${MACHINE} STREQUAL WINDOWS) diff --git a/src/MEDCouplingCorba_Swig/Client/CMakeLists.txt b/src/MEDCouplingCorba_Swig/Client/CMakeLists.txt index cff8d5105..d6634d008 100644 --- a/src/MEDCouplingCorba_Swig/Client/CMakeLists.txt +++ b/src/MEDCouplingCorba_Swig/Client/CMakeLists.txt @@ -24,6 +24,9 @@ INCLUDE(${SWIG_USE_FILE}) SET_SOURCE_FILES_PROPERTIES(MEDCouplingClient.i PROPERTIES CPLUSPLUS ON) SET_SOURCE_FILES_PROPERTIES(MEDCouplingClient.i PROPERTIES SWIG_DEFINITIONS "-shadow") +IF(NUMPY_STATUS) + SET(SWIG_MODULE_MEDCouplingClient_EXTRA_FLAGS -DWITH_NUMPY) +ENDIF(NUMPY_STATUS) INCLUDE_DIRECTORIES( ${PYTHON_INCLUDE_DIRS} @@ -40,7 +43,7 @@ INCLUDE_DIRECTORIES( SWIG_ADD_MODULE(MEDCouplingClient python MEDCouplingClient.i) SWIG_LINK_LIBRARIES(MEDCouplingClient ${PYTHON_LIBS} medcouplingclient) -SET_TARGET_PROPERTIES(_MEDCouplingClient PROPERTIES COMPILE_FLAGS "${OMNIORB_DEFINITIONS} ${PLATFORM_DEFINITIONS}") +SET_TARGET_PROPERTIES(_MEDCouplingClient PROPERTIES COMPILE_FLAGS "${OMNIORB_DEFINITIONS} ${PLATFORM_DEFINITIONS} ${PYTHON_DEFINITIONS}") IF(${MACHINE} STREQUAL WINDOWS) SET_TARGET_PROPERTIES(_MEDCouplingClient PROPERTIES DEBUG_OUTPUT_NAME _MEDCouplingClient_d) ENDIF(${MACHINE} STREQUAL WINDOWS) diff --git a/src/MEDCoupling_Swig/CMakeLists.txt b/src/MEDCoupling_Swig/CMakeLists.txt index 17e8f4310..4890ae86b 100644 --- a/src/MEDCoupling_Swig/CMakeLists.txt +++ b/src/MEDCoupling_Swig/CMakeLists.txt @@ -24,6 +24,9 @@ INCLUDE(${SWIG_USE_FILE}) SET_SOURCE_FILES_PROPERTIES(MEDCoupling.i PROPERTIES CPLUSPLUS ON) SET_SOURCE_FILES_PROPERTIES(MEDCoupling.i PROPERTIES SWIG_DEFINITIONS "-shadow") +IF(NUMPY_STATUS) + SET(SWIG_MODULE_MEDCoupling_EXTRA_FLAGS -DWITH_NUMPY) +ENDIF(NUMPY_STATUS) SET (MEDCoupling_SWIG_DPYS_FILES MEDCouplingCommon.i @@ -52,10 +55,13 @@ SET (SWIG_MODULE_MEDCoupling_EXTRA_DEPS ${MEDCoupling_SWIG_DPYS_FILES} SWIG_ADD_MODULE(MEDCoupling python MEDCoupling.i) SWIG_LINK_LIBRARIES(MEDCoupling ${PYTHON_LIBS} ${PLATFORM_LIBS} medcoupling) -SET_TARGET_PROPERTIES(${SWIG_MODULE_MEDCoupling_REAL_NAME} PROPERTIES COMPILE_FLAGS "${PLATFORM_DEFINITIONS}") +SET_TARGET_PROPERTIES(${SWIG_MODULE_MEDCoupling_REAL_NAME} PROPERTIES COMPILE_FLAGS "${PLATFORM_DEFINITIONS} ${PYTHON_DEFINITIONS}") SET_SOURCE_FILES_PROPERTIES(MEDCouplingRemapper.i PROPERTIES CPLUSPLUS ON) SET_SOURCE_FILES_PROPERTIES(MEDCouplingRemapper.i PROPERTIES SWIG_DEFINITIONS "-shadow") +IF(NUMPY_STATUS) + SET(SWIG_MODULE_MEDCouplingRemapper_EXTRA_FLAGS -DWITH_NUMPY) +ENDIF(NUMPY_STATUS) # _ABR_ Ensure dependency mechanism on all SWIG files and headers SET (SWIG_MODULE_MEDCouplingRemapper_EXTRA_DEPS ${MEDCoupling_SWIG_DPYS_FILES} @@ -64,7 +70,7 @@ SET (SWIG_MODULE_MEDCouplingRemapper_EXTRA_DEPS ${MEDCoupling_SWIG_DPYS_FILES} SWIG_ADD_MODULE(MEDCouplingRemapper python MEDCouplingRemapper.i) SWIG_LINK_LIBRARIES(MEDCouplingRemapper ${PYTHON_LIBS} medcouplingremapper) -SET_TARGET_PROPERTIES(${SWIG_MODULE_MEDCouplingRemapper_REAL_NAME} PROPERTIES COMPILE_FLAGS "${PLATFORM_DEFINITIONS}") +SET_TARGET_PROPERTIES(${SWIG_MODULE_MEDCouplingRemapper_REAL_NAME} PROPERTIES COMPILE_FLAGS "${PLATFORM_DEFINITIONS} ${PYTHON_DEFINITIONS}") IF(${MACHINE} STREQUAL WINDOWS) SET_TARGET_PROPERTIES(_MEDCouplingRemapper PROPERTIES DEBUG_OUTPUT_NAME _MEDCouplingRemapper_d) @@ -76,8 +82,11 @@ SET(PYFILES_TO_INSTALL ${CMAKE_CURRENT_BINARY_DIR}/MEDCoupling.py ${CMAKE_CURREN INSTALL_AND_COMPILE_PYTHON_FILE("${PYFILES_TO_INSTALL}" ${MED_salomescript_PYTHON}) INSTALL(FILES MEDCoupling.i MEDCouplingCommon.i MEDCouplingMemArray.i MEDCouplingFinalize.i MEDCouplingRemapper.i MEDCouplingTypemaps.i DESTINATION ${MED_salomeinclude_HEADERS}) -INSTALL(FILES MEDCouplingBasicsTest.py MEDCouplingRemapperTest.py MEDCouplingDataForTest.py DESTINATION ${MED_salomescript_PYTHON}) +INSTALL(FILES MEDCouplingBasicsTest.py MEDCouplingRemapperTest.py MEDCouplingDataForTest.py MEDCouplingNumpyTest.py DESTINATION ${MED_salomescript_PYTHON}) ADD_TEST(MEDCouplingBasicsTest ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/MEDCouplingBasicsTest.py) ADD_TEST(MEDCouplingExamplesTest ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/MEDCouplingExamplesTest.py) ADD_TEST(MEDCouplingRemapperTest ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/MEDCouplingRemapperTest.py) +IF(NUMPY_STATUS) + ADD_TEST(MEDCouplingNumpyTest ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/MEDCouplingNumpyTest.py) +ENDIF(NUMPY_STATUS) diff --git a/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py b/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py index 0d44b4e6c..b0523db87 100644 --- a/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py +++ b/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py @@ -12549,6 +12549,27 @@ class MEDCouplingBasicsTest(unittest.TestCase): self.assertTrue(cI.isEqual(DataArrayInt([0,2]))) pass + def testSwig2NonRegressionBugChangeUnderlyingWithZeroCells(self): + coords1=[0.,1.,2.,3.] + coords2=[2.,1.,0.,3.] #0 <==> #2 + # mesh 1 + mesh1=MEDCouplingUMesh.New(); + coordsArr=DataArrayDouble.New(coords1,4,1); + mesh1.setCoords(coordsArr); + mesh1.setMeshDimension(0); + mesh1.allocateCells(0); + mesh1.finishInsertingCells(); + # mesh 2 + mesh2=mesh1.deepCpy(); + coordsArr=DataArrayDouble.New(coords2,4,1); + mesh2.setCoords(coordsArr); + field = mesh1.fillFromAnalytic(ON_NODES,1,"x") + field.checkCoherency() + levOfCheck = 10 + field.changeUnderlyingMesh( mesh2, levOfCheck, 1e-13, 0 ) + self.assertTrue( field.getArray().getValues() == coords2 ) + pass + def setUp(self): pass pass diff --git a/src/MEDCoupling_Swig/MEDCouplingCommon.i b/src/MEDCoupling_Swig/MEDCouplingCommon.i index ae3174186..f4b237aba 100644 --- a/src/MEDCoupling_Swig/MEDCouplingCommon.i +++ b/src/MEDCoupling_Swig/MEDCouplingCommon.i @@ -82,7 +82,7 @@ using namespace INTERP_KERNEL; $result=convertDataArrayChar($1,$owner); } -#ifdef WITH_NUMPY2 +#ifdef WITH_NUMPY %init %{ import_array(); %} #endif @@ -486,6 +486,18 @@ namespace ParaMEDMEM }; } +%inline +{ + bool MEDCouplingHasNumpyBindings() + { +#ifdef WITH_NUMPY + return true; +#else + return false; +#endif + } +} + %include "MEDCouplingMemArray.i" namespace ParaMEDMEM diff --git a/src/MEDCoupling_Swig/MEDCouplingExamplesTest.py b/src/MEDCoupling_Swig/MEDCouplingExamplesTest.py index 3f79d2cbb..30d458d5b 100644 --- a/src/MEDCoupling_Swig/MEDCouplingExamplesTest.py +++ b/src/MEDCoupling_Swig/MEDCouplingExamplesTest.py @@ -23,8 +23,453 @@ import unittest from math import pi, sqrt class MEDCouplingBasicsTest(unittest.TestCase): - def testExample_MEDCouplingUMesh_(self): - #! [PySnippet_MEDCouplingUMesh__1] + + def testExample_MEDCouplingFieldDouble_WriteVTK(self): + #! [PySnippet_MEDCouplingFieldDouble_WriteVTK_1] + # mesh + coords = [0.,2.,4.] + coordsArr=DataArrayDouble.New(coords,3,1) + mesh=MEDCouplingCMesh.New() + mesh.setCoords(coordsArr,coordsArr) # mesh becomes a 2D one + + # 3 fields (lying on the same mesh!) + field1 = mesh.getMeasureField( True ) + field2 = mesh.buildOrthogonalField() + field3 = mesh.fillFromAnalytic( ON_CELLS, 2, "IVec * x + JVec * y" ) + field2.setName( "Normal" ) # name is necessary! + field3.setName( "Barycenter" ) # name is necessary! + + # WriteVTK + fileName = "testExample_MEDCouplingFieldDouble_WriteVTK.vtk" + fs = [ field1, field2, field3 ] # field series + MEDCouplingFieldDouble.WriteVTK( fileName, fs ) + #! [PySnippet_MEDCouplingFieldDouble_WriteVTK_1] + import os + os.remove( fileName ) + + return + + def testExample_MEDCouplingFieldDouble_MaxFields(self): + #! [PySnippet_MEDCouplingFieldDouble_MaxFields_1] + vals1 = [0.,2., 4.,6.] # for field 1 + vals2 = [2.,0., 6.,4.] # for field 2 + valsMax = [2.,2., 6.,6.] # expected max field + valsMin = [0.,0., 4.,4.] # expected min field + + # field 1 + valsArr1=DataArrayDouble.New(vals1,2,2) # 2 tuples per 2 components + field1 = MEDCouplingFieldDouble.New( ON_NODES ) + field1.setArray( valsArr1 ) + + # field 2 + valsArr2=DataArrayDouble.New(vals2,2,2) # 2 tuples per 2 components + field2 = MEDCouplingFieldDouble.New( ON_NODES ) + field2.setArray( valsArr2 ) + + # max field + fieldMax = MEDCouplingFieldDouble.MaxFields( field1, field2 ) + self.assertTrue( fieldMax.getArray().getValues() == valsMax ) + + # min field + fieldMin = MEDCouplingFieldDouble.MinFields( field1, field2 ) + self.assertTrue( fieldMin.getArray().getValues() == valsMin ) + #! [PySnippet_MEDCouplingFieldDouble_MaxFields_1] + + def testExample_MEDCouplingFieldDouble_MergeFields(self): + #! [PySnippet_MEDCouplingFieldDouble_MergeFields_1] + # mesh 1 + coords = [0.,2.,4.] + coordsArr=DataArrayDouble.New(coords,3,1) + mesh1=MEDCouplingCMesh.New() + mesh1.setCoords(coordsArr) + # field 1 + field1 = mesh1.fillFromAnalytic( ON_CELLS, 1, "x") + + # mesh 2 and field 2 + field2 = field1.cloneWithMesh( True ) + vec = [5.] + field2.getMesh().translate(vec) # translate mesh2 + field2.applyFunc("x + 5") # "translate" field2 + + # concatenate field1 and field2 + field3 = MEDCouplingFieldDouble.MergeFields( field1, field2 ) + field4 = MEDCouplingFieldDouble.MergeFields( [ field1, field2] ) + #! [PySnippet_MEDCouplingFieldDouble_MergeFields_1] + return + + def testExample_MEDCouplingFieldDouble_substractInPlaceDM(self): + #! [PySnippet_MEDCouplingFieldDouble_substractInPlaceDM_1] + coords1=[0.,1.,2.,3.] + coords2=[2.,1.,0.,3.] #0 <==> #2 + # mesh 1 + mesh1=MEDCouplingUMesh.New(); + coordsArr=DataArrayDouble.New(coords1, 4, 1); + mesh1.setCoords(coordsArr); + mesh1.setMeshDimension(0); + mesh1.allocateCells(0); + mesh1.finishInsertingCells(); + # mesh 2 + mesh2=mesh1.deepCpy(); + mesh2.getCoords().setValues(coords2, 4, 1); + #! [PySnippet_MEDCouplingFieldDouble_substractInPlaceDM_1] + #! [PySnippet_MEDCouplingFieldDouble_substractInPlaceDM_2] + field1 = mesh1.fillFromAnalytic(ON_NODES,1,"x") # field1 values == coords1 + field2 = mesh2.fillFromAnalytic(ON_NODES,1,"x") # field2 values == coords2 + levOfCheck = 10 # nodes can be permuted + field1.substractInPlaceDM( field2, levOfCheck, 1e-13, 0 ) # values #0 and #2 must swap + #! [PySnippet_MEDCouplingFieldDouble_substractInPlaceDM_2] + #! [PySnippet_MEDCouplingFieldDouble_substractInPlaceDM_3] + field2.applyFunc( 1, 0.0 ) # all field2 values == 0.0 + self.assertTrue( field1.isEqual( field2, 1e-13, 1e-13 )) # field1 == field2 == 0.0 + #! [PySnippet_MEDCouplingFieldDouble_substractInPlaceDM_3] + return + + def testExample_MEDCouplingFieldDouble_changeUnderlyingMesh(self): + #! [PySnippet_MEDCouplingFieldDouble_changeUnderlyingMesh_1] + coords1=[0.,1.,2.,3.] + coords2=[2.,1.,0.,3.] #0 <==> #2 + # mesh 1 + mesh1=MEDCouplingUMesh.New(); + coordsArr=DataArrayDouble.New(coords1, 4, 1); + mesh1.setCoords(coordsArr); + mesh1.setMeshDimension(0); + mesh1.allocateCells(0); + mesh1.finishInsertingCells(); + # mesh 2 + mesh2=mesh1.deepCpy(); + mesh2.getCoords().setValues(coords2, 4, 1); + #! [PySnippet_MEDCouplingFieldDouble_changeUnderlyingMesh_1] + #! [PySnippet_MEDCouplingFieldDouble_changeUnderlyingMesh_2] + field = mesh1.fillFromAnalytic(ON_NODES,1,"x") # field values == coords1 + levOfCheck = 10 # nodes can be permuted + field.changeUnderlyingMesh( mesh2, levOfCheck, 1e-13, 0 ) # values #0 and #2 must swap + self.assertTrue( field.getArray().getValues() == coords2 ) + #! [PySnippet_MEDCouplingFieldDouble_changeUnderlyingMesh_2] + return + + def testExample_MEDCouplingFieldDouble_applyFunc_same_nb_comp(self): + #! [PySnippet_MEDCouplingFieldDouble_applyFunc_same_nb_comp_1] + v = [1.,2., 3.,4.] + array = DataArrayDouble.New( v, 2, 2 ) # 2 tuples per 2 components + field = MEDCouplingFieldDouble.New( ON_CELLS ) + field.setArray( array ) + func = "IVec * v + JVec * v*v + 10" + field.applyFunc( func ) + self.assertTrue( field.getNumberOfComponents() == 2 ) # 2 components remains + #! [PySnippet_MEDCouplingFieldDouble_applyFunc_same_nb_comp_1] + #! [PySnippet_MEDCouplingFieldDouble_applyFunc_same_nb_comp_2] + v2 = field.getArray().getValues() + self.assertAlmostEqual( v2[0], 10 + v[0], 13 ) # "10 + IVec * v" + self.assertAlmostEqual( v2[1], 10 + v[1]*v[1], 13 ) # "10 + JVec * v*v" + self.assertAlmostEqual( v2[2], 10 + v[2], 13 ) # "10 + IVec * v" + self.assertAlmostEqual( v2[3], 10 + v[3]*v[3], 13 ) # "10 + JVec * v*v" + #! [PySnippet_MEDCouplingFieldDouble_applyFunc_same_nb_comp_2] + return + + def testExample_MEDCouplingFieldDouble_applyFunc3(self): + #! [PySnippet_MEDCouplingFieldDouble_applyFunc3_1] + # create a 2D vector field + values = [1.,1., 2.,1.] + array = DataArrayDouble.New( values, 2, 2 ) # 2 tuples per 2 components + field = MEDCouplingFieldDouble.New( ON_CELLS ) + field.setArray( array ) + # transform the field to a 3D vector field + func = "IVec * b + JVec * a + KVec * sqrt( a*a + b*b ) + 10" + varNames=["a","b"] # names used to refer to X and Y components + field.applyFunc3( 3, varNames, func ) # require 3 components + self.assertTrue( field.getNumberOfComponents() == 3 ) # 3 components as required + #! [PySnippet_MEDCouplingFieldDouble_applyFunc3_1] + #! [PySnippet_MEDCouplingFieldDouble_applyFunc3_2] + vec1 = field.getArray().getTuple(1) # vector #1 + a,b = values[2], values[3] # initial components of the vector #1 + self.assertAlmostEqual( vec1[0], 10 + b, 13 ) # "10 + IVec * b" + self.assertAlmostEqual( vec1[1], 10 + a, 13 ) # "10 + JVec * a" + self.assertAlmostEqual( vec1[2], 10 + sqrt(a*a+b*b), 13 ) # "10 + KVec * sqrt( a*a + b*b )" + #! [PySnippet_MEDCouplingFieldDouble_applyFunc3_2] + return + + def testExample_MEDCouplingFieldDouble_applyFunc2(self): + #! [PySnippet_MEDCouplingFieldDouble_applyFunc2_1] + # create a 2D vector field + values = [1.,1., 2.,1.] + array = DataArrayDouble.New( values, 2, 2 ) # 2 tuples per 2 components + array.setInfoOnComponent(0,"a") # name used to refer to X component within a function + array.setInfoOnComponent(1,"b") # name used to refer to Y component within a function + field = MEDCouplingFieldDouble.New( ON_CELLS ) + field.setArray( array ) + # transform the field to a 3D vector field + func = "IVec * b + JVec * a + KVec * sqrt( a*a + b*b ) + 10" + field.applyFunc2( 3, func ) # require 3 components + self.assertTrue( field.getNumberOfComponents() == 3 ) # 3 components as required + #! [PySnippet_MEDCouplingFieldDouble_applyFunc2_1] + #! [PySnippet_MEDCouplingFieldDouble_applyFunc2_2] + vec1 = field.getArray().getTuple(1) # vector #1 + a,b = values[2], values[3] # initial components of the vector #1 + self.assertAlmostEqual( vec1[0], 10 + b, 13 ) # "10 + IVec * b" + self.assertAlmostEqual( vec1[1], 10 + a, 13 ) # "10 + JVec * a" + self.assertAlmostEqual( vec1[2], 10 + sqrt(a*a+b*b), 13 ) # "10 + KVec * sqrt( a*a + b*b )" + #! [PySnippet_MEDCouplingFieldDouble_applyFunc2_2] + return + + def testExample_MEDCouplingFieldDouble_applyFunc(self): + #! [PySnippet_MEDCouplingFieldDouble_applyFunc_1] + # create a 2D vector field + values = [1.,1., 2.,1.] + array = DataArrayDouble.New( values, 2, 2 ) # 2 tuples per 2 components + field = MEDCouplingFieldDouble.New( ON_CELLS ) + field.setArray( array ) + # transform the field to a 3D vector field + func = "IVec * b + JVec * a + KVec * sqrt( a*a + b*b ) + 10" + field.applyFunc( 3, func ) # require 3 components + self.assertTrue( field.getNumberOfComponents() == 3 ) # 3 components as required + #! [PySnippet_MEDCouplingFieldDouble_applyFunc_1] + #! [PySnippet_MEDCouplingFieldDouble_applyFunc_2] + vec1 = field.getArray().getTuple(1) # vector #1 + a,b = values[2], values[3] # initial components of the vector #1 + self.assertAlmostEqual( vec1[0], 10 + b, 13 ) # "10 + IVec * b" + self.assertAlmostEqual( vec1[1], 10 + a, 13 ) # "10 + JVec * a" + self.assertAlmostEqual( vec1[2], 10 + sqrt(a*a+b*b), 13 ) # "10 + KVec * sqrt( a*a + b*b )" + #! [PySnippet_MEDCouplingFieldDouble_applyFunc_2] + return + + def testExample_MEDCouplingFieldDouble_applyFunc_val(self): + #! [PySnippet_MEDCouplingFieldDouble_applyFunc_val_1] + coords = [0.,2.,4.] + coordsArr=DataArrayDouble.New(coords,3,1) + mesh=MEDCouplingCMesh.New() + mesh.setCoords(coordsArr,coordsArr) + field = MEDCouplingFieldDouble.New( ON_CELLS ) + field.setMesh( mesh ) + field.fillFromAnalytic(2,"IVec * x + JVec * y") # 2 components + #! [PySnippet_MEDCouplingFieldDouble_applyFunc_val_1] + #! [PySnippet_MEDCouplingFieldDouble_applyFunc_val_2] + newValue = 7. + field.applyFunc( 3, newValue ) # 3 components are required + self.assertTrue( field.getIJ(1,0) == newValue ) # a value is as expected + self.assertTrue( field.getNumberOfComponents() == 3 ) + self.assertTrue( field.getNumberOfTuples() == mesh.getNumberOfCells() ) + #! [PySnippet_MEDCouplingFieldDouble_applyFunc_val_2] + return + + def testExample_MEDCouplingFieldDouble_fillFromAnalytic3(self): + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic3_1] + coords = [0.,2.,4.,6.] # 6. is not used + x=DataArrayDouble.New(coords[:3],3,1) + y=DataArrayDouble.New(coords[:2],2,1) + mesh=MEDCouplingCMesh.New() + mesh.setCoords(x,y) + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic3_1] + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic3_2] + field = MEDCouplingFieldDouble.New( ON_CELLS ) + field.setMesh( mesh ) + func = "IVec * b + JVec * a + KVec * sqrt( a*a + b*b ) + 10" + varNames=["a","b"] # names used to refer to X and Y coord components + field.fillFromAnalytic3(3,varNames,func) + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic3_2] + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic3_3] + vals1 = field.getArray().getTuple(1) # values of the cell #1 + assert len( vals1 ) == 3 # 3 components in the field + # + bc = mesh.getBarycenterAndOwner() # func is applied to barycenters of cells + bc1 = bc.getTuple(1) # coordinates of the second point + # + dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ) # "sqrt( a*a + b*b )" + self.assertAlmostEqual( vals1[0], 10 + bc1[1], 13 ) # "10 + IVec * b" + self.assertAlmostEqual( vals1[1], 10 + bc1[0], 13 ) # "10 + JVec * a" + self.assertAlmostEqual( vals1[2], 10 + dist , 13 ) # "10 + KVec * sqrt( a*a + b*b )" + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic3_3] + return + + def testExample_MEDCouplingFieldDouble_fillFromAnalytic2(self): + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic2_1] + coords = [0.,2.,4.] + x=DataArrayDouble.New(coords[:3],3,1) + y=DataArrayDouble.New(coords[:2],2,1) + x.setInfoOnComponent(0,"a") # name used to refer to X coordinate within a function + y.setInfoOnComponent(0,"b") # name used to refer to Y coordinate within a function + mesh=MEDCouplingCMesh.New() + mesh.setCoords(x,y) + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic2_1] + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic2_2] + field = MEDCouplingFieldDouble.New( ON_CELLS ) + field.setMesh( mesh ) + func = "IVec * b + JVec * a + KVec * sqrt( a*a + b*b ) + 10" + field.fillFromAnalytic2(3,func) + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic2_2] + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic2_3] + vals1 = field.getArray().getTuple(1) # values of the cell #1 + assert len( vals1 ) == 3 # 3 components in the field + # + bc = mesh.getBarycenterAndOwner() # func is applied to barycenters of cells + bc1 = bc.getTuple(1) # coordinates of the second point + # + dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ) # "sqrt( a*a + b*b )" + self.assertAlmostEqual( vals1[0], 10 + bc1[1], 13 ) # "10 + IVec * b" + self.assertAlmostEqual( vals1[1], 10 + bc1[0], 13 ) # "10 + JVec * a" + self.assertAlmostEqual( vals1[2], 10 + dist , 13 ) # "10 + KVec * sqrt( a*a + b*b )" + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic2_3] + return + + def testExample_MEDCouplingFieldDouble_fillFromAnalytic(self): + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic_1] + coords = [0.,2.,4.] + x=DataArrayDouble.New(coords[:3],3,1) + y=DataArrayDouble.New(coords[:2],2,1) + mesh=MEDCouplingCMesh.New() + mesh.setCoords(x,y) + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic_1] + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic_2] + field = MEDCouplingFieldDouble.New( ON_CELLS ) + field.setMesh( mesh ) + func = "IVec * b + JVec * a + KVec * sqrt( a*a + b*b ) + 10" + field.fillFromAnalytic(3,func) + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic_2] + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic_3] + vals1 = field.getArray().getTuple(1) # values of the cell #1 + assert len( vals1 ) == 3 # 3 components in the field + # + bc = mesh.getBarycenterAndOwner() # func is applied to barycenters of cells + bc1 = bc.getTuple(1) # coordinates of the second point + # + dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ) # "sqrt( a*a + b*b )" + self.assertAlmostEqual( vals1[0], 10 + bc1[1], 13 ) # "10 + IVec * b" + self.assertAlmostEqual( vals1[1], 10 + bc1[0], 13 ) # "10 + JVec * a" + self.assertAlmostEqual( vals1[2], 10 + dist , 13 ) # "10 + KVec * sqrt( a*a + b*b )" + #! [PySnippet_MEDCouplingFieldDouble_fillFromAnalytic_3] + return + + def testExample_MEDCouplingFieldDouble_getValueOn_time(self): + #! [PySnippet_MEDCouplingFieldDouble_getValueOn_time_1] + coords = [0.,2.,4.] + coordsArr=DataArrayDouble.New(coords,3,1) + mesh=MEDCouplingCMesh.New() + mesh.setCoords(coordsArr,coordsArr) + #! [PySnippet_MEDCouplingFieldDouble_getValueOn_time_1] + #! [PySnippet_MEDCouplingFieldDouble_getValueOn_time_2] + field = MEDCouplingFieldDouble.New( ON_CELLS, LINEAR_TIME ) + field.setMesh( mesh ) + field.fillFromAnalytic(1,"10") # all values == 10. + field.setEndArray( field.getArray() + field.getArray() ) # all values == 20. + time1, time2 = 1.1, 22. + field.setStartTime( time1, 0, 0 ) + field.setEndTime ( time2, 0, 0 ) + #! [PySnippet_MEDCouplingFieldDouble_getValueOn_time_2] + #! [PySnippet_MEDCouplingFieldDouble_getValueOn_time_3] + pos = [ 1., 1. ] # we are in 2D space + value = field.getValueOn( pos, 0.5*( time1 + time2 )) + self.assertTrue( value[0] == 0.5*( 10. + 20.)) + #! [PySnippet_MEDCouplingFieldDouble_getValueOn_time_3] + return + + def testExample_MEDCouplingFieldDouble_getValueOnMulti(self): + #! [PySnippet_MEDCouplingFieldDouble_getValueOnMulti_1] + coords = [0.,2.,4.] + coordsArr=DataArrayDouble.New(coords,3,1) + mesh=MEDCouplingCMesh.New() + mesh.setCoords(coordsArr,coordsArr) + field = mesh.fillFromAnalytic(ON_CELLS,1,"x+y") + #! [PySnippet_MEDCouplingFieldDouble_getValueOnMulti_1] + #! [PySnippet_MEDCouplingFieldDouble_getValueOnMulti_2] + bc = mesh.getBarycenterAndOwner() # field values are located at cell barycenters + valArray = field.getValueOnMulti( bc.getValues() ) + self.assertTrue( valArray.isEqual( field.getArray(), 1e-13 )) + #! [PySnippet_MEDCouplingFieldDouble_getValueOnMulti_2] + return + + def testExample_MEDCouplingFieldDouble_getValueOn(self): + #! [PySnippet_MEDCouplingFieldDouble_getValueOn_1] + coords = [0.,2.,4.] + coordsArr=DataArrayDouble.New(coords,3,1) + mesh=MEDCouplingCMesh.New() + mesh.setCoords(coordsArr,coordsArr) + field = mesh.fillFromAnalytic(ON_CELLS,1,"x+y") + #! [PySnippet_MEDCouplingFieldDouble_getValueOn_1] + #! [PySnippet_MEDCouplingFieldDouble_getValueOn_2] + bc = mesh.getBarycenterAndOwner() # field values are located at cell barycenters + vals = [] # array to collect values returned by getValueOn() + for i in range( bc.getNumberOfTuples() ): + vals.extend( field.getValueOn( bc.getTuple( i ))) + self.assertTrue( vals == field.getArray().getValues() ) + #! [PySnippet_MEDCouplingFieldDouble_getValueOn_2] + return + + def testExample_MEDCouplingFieldDouble_getValueOnPos(self): + #! [PySnippet_MEDCouplingFieldDouble_getValueOnPos_1] + coords = [0.,2.,4.] + coordsArr=DataArrayDouble.New(coords,3,1) + mesh=MEDCouplingCMesh.New() + mesh.setCoords(coordsArr,coordsArr) + field = mesh.fillFromAnalytic(ON_CELLS,1,"x+y") + #! [PySnippet_MEDCouplingFieldDouble_getValueOnPos_1] + #! [PySnippet_MEDCouplingFieldDouble_getValueOnPos_2] + val11 = field.getValueOnPos( 1,1,-1) + bc = mesh.getBarycenterAndOwner() # field values are located at cell barycenters + self.assertTrue( val11[0] == bc[3,0] + bc[3,1] ) + #! [PySnippet_MEDCouplingFieldDouble_getValueOnPos_2] + return + + def testExample_MEDCouplingFieldDouble_renumberNodes(self): + #! [PySnippet_MEDCouplingFieldDouble_renumberNodes_1] + coords = [0.,2.,4.] + coordsArr=DataArrayDouble.New(coords,3,1) + mesh=MEDCouplingCMesh.New() + mesh.setCoords(coordsArr,coordsArr) + mesh=mesh.buildUnstructured() + #! [PySnippet_MEDCouplingFieldDouble_renumberNodes_1] + #! [PySnippet_MEDCouplingFieldDouble_renumberNodes_2] + field = mesh.fillFromAnalytic(ON_NODES,2,"IVec*x+JVec*y") + values = field.getArray() + nodeCoords = mesh.getCoords() + self.assertTrue( values.isEqualWithoutConsideringStr( nodeCoords, 1e-13 )) + #! [PySnippet_MEDCouplingFieldDouble_renumberNodes_2] + #! [PySnippet_MEDCouplingFieldDouble_renumberNodes_3] + renumber = [8, 7, 6, 5, 4, 3, 2, 1, 0] + field.renumberNodes(renumber,False) + mesh2 = field.getMesh() # field now refers to another mesh + values = field.getArray() + nodeCoords = mesh2.getCoords() + self.assertTrue( values.isEqualWithoutConsideringStr( nodeCoords, 1e-13 )) + #! [PySnippet_MEDCouplingFieldDouble_renumberNodes_3] + return + + + def testExample_MEDCouplingFieldDouble_renumberCells(self): + #! [PySnippet_MEDCouplingFieldDouble_renumberCells_1] + coords = [0.,2.,4.] + coordsArr=DataArrayDouble.New(coords,3,1) + mesh=MEDCouplingCMesh.New() + mesh.setCoords(coordsArr,coordsArr) + mesh=mesh.buildUnstructured() + #! [PySnippet_MEDCouplingFieldDouble_renumberCells_1] + #! [PySnippet_MEDCouplingFieldDouble_renumberCells_2] + field = mesh.fillFromAnalytic(ON_CELLS,2,"IVec*x+JVec*y") + values = field.getArray() + bc = mesh.getBarycenterAndOwner() + self.assertTrue( values.isEqualWithoutConsideringStr( bc, 1e-13 )) + #! [PySnippet_MEDCouplingFieldDouble_renumberCells_2] + #! [PySnippet_MEDCouplingFieldDouble_renumberCells_3] + renumber = [ 3, 2, 1, 0 ] + field.renumberCells(renumber,False) + mesh2 = field.getMesh() # field now refers to another mesh + values = field.getArray() + bc = mesh2.getBarycenterAndOwner() + self.assertTrue( values.isEqualWithoutConsideringStr( bc, 1e-13 )) + #! [PySnippet_MEDCouplingFieldDouble_renumberCells_3] + return + + def testExample_MEDCouplingFieldDouble_buildNewTimeReprFromThis(self): + #! [PySnippet_MEDCouplingFieldDouble_buildNewTimeReprFromThis_1] + coords = [0.,2.,4.] + coordsArr=DataArrayDouble.New(coords,3,1) + mesh=MEDCouplingCMesh.New() + mesh.setCoords(coordsArr,coordsArr) + field1 = mesh.fillFromAnalytic(ON_NODES,1,"x+y") + self.assertTrue( field1.getTimeDiscretization() == ONE_TIME ) + #! [PySnippet_MEDCouplingFieldDouble_buildNewTimeReprFromThis_1] + #! [PySnippet_MEDCouplingFieldDouble_buildNewTimeReprFromThis_2] + field2 = field1.buildNewTimeReprFromThis(NO_TIME,False) + self.assertTrue( field2.getTimeDiscretization() == NO_TIME ) + #! [PySnippet_MEDCouplingFieldDouble_buildNewTimeReprFromThis_2] return def testExample_MEDCouplingMesh_fillFromAnalytic3(self): diff --git a/src/MEDCoupling_Swig/MEDCouplingMemArray.i b/src/MEDCoupling_Swig/MEDCouplingMemArray.i index af37bec17..9b916b298 100644 --- a/src/MEDCoupling_Swig/MEDCouplingMemArray.i +++ b/src/MEDCoupling_Swig/MEDCouplingMemArray.i @@ -284,6 +284,12 @@ namespace ParaMEDMEM return ret.retn(); } } +#ifdef WITH_NUMPY + else if(PyArray_Check(elt0)) + {//DataArrayDouble.New(numpyArray) + return BuildNewInstance(elt0,NPY_DOUBLE,&PyCallBackDataArrayDouble_RefType,"FLOAT64"); + } +#endif else throw INTERP_KERNEL::Exception(msg); } @@ -389,6 +395,13 @@ namespace ParaMEDMEM return convertDblArrToPyList(vals,self->getNbOfElems()); } +#ifdef WITH_NUMPY + PyObject *toNumPyArray() throw(INTERP_KERNEL::Exception) // not const. It is not a bug ! + { + return ToNumPyArray(self,NPY_DOUBLE,"DataArrayDouble"); + } +#endif + PyObject *isEqualIfNotWhy(const DataArrayDouble& other, double prec) const throw(INTERP_KERNEL::Exception) { std::string ret1; @@ -2353,6 +2366,12 @@ namespace ParaMEDMEM return ret.retn(); } } +#ifdef WITH_NUMPY + else if(PyArray_Check(elt0)) + {//DataArrayInt.New(numpyArray) + return BuildNewInstance(elt0,NPY_INT,&PyCallBackDataArrayInt_RefType,"INT32"); + } +#endif else throw INTERP_KERNEL::Exception(msg); } @@ -2463,6 +2482,13 @@ namespace ParaMEDMEM return convertIntArrToPyList(vals,self->getNbOfElems()); } +#ifdef WITH_NUMPY + PyObject *toNumPyArray() throw(INTERP_KERNEL::Exception) // not const. It is not a bug ! + { + return ToNumPyArray(self,NPY_INT,"DataArrayInt"); + } +#endif + PyObject *isEqualIfNotWhy(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception) { std::string ret1; diff --git a/src/MEDCoupling_Swig/MEDCouplingNumpyTest.py b/src/MEDCoupling_Swig/MEDCouplingNumpyTest.py new file mode 100644 index 000000000..b6f54f119 --- /dev/null +++ b/src/MEDCoupling_Swig/MEDCouplingNumpyTest.py @@ -0,0 +1,356 @@ +# -*- coding: iso-8859-1 -*- +# Copyright (C) 2007-2013 CEA/DEN, EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +# + +from MEDCoupling import * + +if MEDCouplingHasNumpyBindings(): + from numpy import * + pass + +from sys import getrefcount + +import os,gc,weakref,unittest + +class MEDCouplingNumpyTest(unittest.TestCase): + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test1(self): + sz=20 + a=array(0,dtype=int32) + a.resize(sz) + a[:]=4 + self.assertEqual(getrefcount(a),2) + a=a.cumsum(dtype=int32) + self.assertEqual(getrefcount(a),2) + d=DataArrayInt(a) + d[:]=2 + # + e=DataArrayInt(sz) ; e.fillWithValue(2) + self.assertTrue(d.isEqual(e)) + # + a[:]=4 ; e.fillWithValue(4) + self.assertTrue(d.isEqual(e)) + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test2(self): + sz=20 + a=array(0,dtype=int32) + a.resize(sz,2) + self.assertEqual(getrefcount(a),2) + b=a.reshape(2*sz) + self.assertEqual(getrefcount(a),3) + self.assertEqual(getrefcount(b),2) + b[:]=5 + d=DataArrayInt(b) + # + e=DataArrayInt(sz*2) ; e.fillWithValue(5) + self.assertTrue(d.isEqual(e)) + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test3(self): + sz=10 + a=array(0,dtype=int32) + a.resize(sz,2) + b=a.reshape(2*sz) + c=a.reshape(2,sz) + b[:]=6 + b[7:17]=7 + d=DataArrayInt(b) + self.assertTrue(d.isEqual(DataArrayInt([6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,6,6,6]))) + # + a=zeros((10,2),dtype=int32) + b=a.T + c=b.view() + a.shape=20 + a[3:]=10. + d=DataArrayInt(a) + self.assertTrue(d.isEqual(DataArrayInt([0,0,0,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]))) + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test4(self): + a=zeros(20,dtype=int32) + b = a[::-1] + self.assertRaises(InterpKernelException,DataArrayInt.New,b) # b is not contiguous in memory + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test5(self): + a=arange(20,dtype=int32) + self.assertEqual(weakref.getweakrefcount(a),0) + d=DataArrayInt(a) + self.assertEqual(weakref.getweakrefcount(a),1) + self.assertTrue(not a.flags["OWNDATA"]) + self.assertTrue(d.isIdentity()) + self.assertEqual(len(d),20) + a[:]=2 # modifying a and d because a and d share the same chunk of data + self.assertTrue(d.isUniform(2)) + del d # d is destroyed, a retrieves its ownership of its initial chunk of data + self.assertTrue(a.flags["OWNDATA"]) + a[:]=4 # a can be used has usual + self.assertTrue(DataArrayInt(a).isUniform(4)) + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test6(self): + a=arange(20,dtype=int32) + d=DataArrayInt(a) # d owns data of a + e=DataArrayInt(a) # a not owned -> e only an access to chunk of a + self.assertTrue(d.isIdentity()) + self.assertTrue(e.isIdentity()) + a[:]=6 + self.assertTrue(d.isUniform(6)) + self.assertTrue(e.isUniform(6)) + del a # a destroyed -> d no change because owned and e array is has no more data set + self.assertTrue(d.isUniform(6)) + self.assertTrue(not e.isAllocated()) + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test7(self): + a=array(0,dtype=int32) ; a.resize(10,2) + b=a.reshape(20) + c=a.reshape(2,10) + d=DataArrayInt(b) # d owns data of a + e=DataArrayInt(b) # a not owned -> e only an access to chunk of a + f=DataArrayInt(b) # a not owned -> e only an access to chunk of a + del d # d removed -> a ownes again data + self.assertTrue(e.isUniform(0)) + e[:]=6 + self.assertTrue(e.isUniform(6)) + self.assertTrue(f.isUniform(6)) + self.assertEqual(b.tolist(),[6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6]) + self.assertEqual(a.tolist(),[[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6]]) + b[:]=arange(20) + del b # no impact on e and f because a is the base of a. + self.assertTrue(f.isIdentity()) + self.assertTrue(e.isIdentity()) + del a # a destroyed, but as c has its base set to a, a exists -> e and f not allocated + self.assertTrue(f.isIdentity()) + self.assertTrue(e.isIdentity()) + del c # c killed -> a killed -> e and d are put into not allocated state + self.assertTrue(not e.isAllocated()) + self.assertTrue(not f.isAllocated()) + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test8(self): + a=arange(20,dtype=int32) + self.assertTrue(a.flags["OWNDATA"]) + d=DataArrayInt(a) # d owns data of a + self.assertTrue(not a.flags["OWNDATA"]) + d.pushBackSilent(20)# d pushBack so release of chunk of data -> a becomes owner of its data again + self.assertTrue(a.flags["OWNDATA"]) + self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]))) + self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]) + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test9(self): + sz=20 + a=array(0,dtype=float64) + a.resize(sz) + a[:]=4 + self.assertEqual(getrefcount(a),2) + a=a.cumsum(dtype=float64) + self.assertEqual(getrefcount(a),2) + d=DataArrayDouble(a) + d[:]=2 + # + e=DataArrayDouble(sz) ; e.fillWithValue(2) + self.assertTrue(d.isEqual(e,1e-14)) + # + a[:]=4 ; e.fillWithValue(4) + self.assertTrue(d.isEqual(e,1e-14)) + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test10(self): + sz=20 + a=array(0,dtype=float64) + a.resize(sz,2) + self.assertEqual(getrefcount(a),2) + b=a.reshape(2*sz) + self.assertEqual(getrefcount(a),3) + self.assertEqual(getrefcount(b),2) + b[:]=5 + d=DataArrayDouble(b) + # + e=DataArrayDouble(sz*2) ; e.fillWithValue(5) + self.assertTrue(d.isEqual(e,1e-14)) + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test11(self): + sz=10 + a=array(0,dtype=float64) + a.resize(sz,2) + b=a.reshape(2*sz) + c=a.reshape(2,sz) + b[:]=6 + b[7:17]=7 + d=DataArrayDouble(b) + self.assertTrue(d.isEqual(DataArrayDouble([6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,6,6,6]),1e-14)) + # + a=zeros((10,2),dtype=float64) + b=a.T + c=b.view() + a.shape=20 + a[3:]=10. + d=DataArrayDouble(a) + self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]),1e-14)) + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test12(self): + a=zeros(20,dtype=float64) + b = a[::-1] + self.assertRaises(InterpKernelException,DataArrayDouble.New,b) # b is not contiguous in memory + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test13(self): + a=arange(20,dtype=float64) + self.assertEqual(weakref.getweakrefcount(a),0) + d=DataArrayDouble(a) + self.assertEqual(weakref.getweakrefcount(a),1) + self.assertTrue(not a.flags["OWNDATA"]) + self.assertTrue(d.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-14)) + self.assertEqual(len(d),20) + a[:]=2 # modifying a and d because a and d share the same chunk of data + self.assertTrue(d.isUniform(2,1e-14)) + del d # d is destroyed, a retrieves its ownership of its initial chunk of data + self.assertTrue(a.flags["OWNDATA"]) + a[:]=4 # a can be used has usual + self.assertTrue(DataArrayDouble(a).isUniform(4,1e-14)) + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test14(self): + a=arange(20,dtype=float64) + d=DataArrayDouble(a) # d owns data of a + e=DataArrayDouble(a) # a not owned -> e only an access to chunk of a + self.assertTrue(d.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-14)) + self.assertTrue(e.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-14)) + a[:]=6 + self.assertTrue(d.isUniform(6,1e-14)) + self.assertTrue(e.isUniform(6,1e-14)) + del a # a destroyed -> d no change because owned and e array is has no more data set + self.assertTrue(d.isUniform(6,1e-14)) + self.assertTrue(not e.isAllocated()) + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test15(self): + a=array(0,dtype=float64) ; a.resize(10,2) + b=a.reshape(20) + c=a.reshape(2,10) + d=DataArrayDouble(b) # d owns data of a + e=DataArrayDouble(b) # a not owned -> e only an access to chunk of a + f=DataArrayDouble(b) # a not owned -> e only an access to chunk of a + del d # d removed -> a ownes again data + self.assertTrue(e.isUniform(0,1e-14)) + e[:]=6 + self.assertTrue(e.isUniform(6,1e-14)) + self.assertTrue(f.isUniform(6,1e-14)) + self.assertEqual(b.tolist(),[6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6]) + self.assertEqual(a.tolist(),[[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6]]) + b[:]=arange(20) + del b # no impact on e and f because a is the base of a. + self.assertTrue(f.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-14)) + self.assertTrue(e.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-14)) + del a # a destroyed, but as c has its base set to a, a exists -> e and f not allocated + self.assertTrue(f.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-14)) + self.assertTrue(e.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-14)) + del c # c killed -> a killed -> e and d are put into not allocated state + self.assertTrue(not e.isAllocated()) + self.assertTrue(not f.isAllocated()) + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test16(self): + a=arange(20,dtype=float64) + self.assertTrue(a.flags["OWNDATA"]) + d=DataArrayDouble(a) # d owns data of a + self.assertTrue(not a.flags["OWNDATA"]) + d.pushBackSilent(20)# d pushBack so release of chunk of data -> a becomes owner of its data again + self.assertTrue(a.flags["OWNDATA"]) + self.assertTrue(d.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]),1e-14)) + self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]) + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test17(self): + d=DataArrayInt.Range(0,20,1) + d.rearrange(10) + self.assertRaises(InterpKernelException,d.toNumPyArray)# forbidden one or two components of d is accepted + d.rearrange(1) + a=d.toNumPyArray() + self.assertTrue(not a.flags["OWNDATA"]) + a[-2:]=100 + self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,100,100]))) + self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,100,100]) + del a + self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,100,100]))) + # + d.rearrange(2) + a=d.toNumPyArray() + self.assertTrue(not a.flags["OWNDATA"]) + a[-2:]=200 + self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,200,200,200,200],10,2))) + self.assertEqual(a.tolist(),[[0,1],[2,3],[4,5],[6,7],[8,9],[10,11],[12,13],[14,15],[200,200],[200,200]]) + del a + self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,200,200,200,200],10,2))) + pass + + @unittest.skipUnless(MEDCouplingHasNumpyBindings(),"requires numpy") + def test18(self): + d=DataArrayInt.Range(0,20,1) + d=d.convertToDblArr() + d.rearrange(10) + self.assertRaises(InterpKernelException,d.toNumPyArray)# forbidden one or two components of d is accepted + d.rearrange(1) + a=d.toNumPyArray() + self.assertTrue(not a.flags["OWNDATA"]) + a[-2:]=100 + self.assertTrue(d.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,100,100]),1e-14)) + self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,100,100]) + del a + self.assertTrue(d.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,100,100]),1e-14)) + # + d.rearrange(2) + a=d.toNumPyArray() + self.assertTrue(not a.flags["OWNDATA"]) + a[-2:]=200 + self.assertTrue(d.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,200,200,200,200],10,2),1e-14)) + self.assertEqual(a.tolist(),[[0,1],[2,3],[4,5],[6,7],[8,9],[10,11],[12,13],[14,15],[200,200],[200,200]]) + del a + self.assertTrue(d.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,200,200,200,200],10,2),1e-14)) + pass + + def setUp(self): + pass + pass + +#gc.set_debug(gc.DEBUG_LEAK) +unittest.main() diff --git a/src/MEDCoupling_Swig/MEDCouplingTypemaps.i b/src/MEDCoupling_Swig/MEDCouplingTypemaps.i index fbbf34ea6..fe655d9aa 100644 --- a/src/MEDCoupling_Swig/MEDCouplingTypemaps.i +++ b/src/MEDCoupling_Swig/MEDCouplingTypemaps.i @@ -19,8 +19,292 @@ #include "InterpKernelAutoPtr.hxx" -#ifdef WITH_NUMPY2 +#ifdef WITH_NUMPY #include + +void numarrdeal(void *pt, void *wron) +{ + void **wronc=(void **)wron; + PyObject *weakRefOnOwner=reinterpret_cast(wronc[0]); + PyObject *obj=PyWeakref_GetObject(weakRefOnOwner); + if(obj!=Py_None) + { + Py_XINCREF(obj); + PyArrayObject *objC=reinterpret_cast(obj); + objC->flags|=NPY_OWNDATA; + Py_XDECREF(weakRefOnOwner); + Py_XDECREF(obj); + } + else + { + typedef void (*MyDeallocator)(void *,void *); + MyDeallocator deall=(MyDeallocator)wronc[1]; + deall(pt,NULL); + } + delete [] wronc; +} + +template +struct PyCallBackDataArraySt { + PyObject_HEAD + MCData *_pt_mc; +}; + +typedef struct PyCallBackDataArraySt PyCallBackDataArrayInt; +typedef struct PyCallBackDataArraySt PyCallBackDataArrayDouble; + +extern "C" +{ + static int callbackmcdataarray___init__(PyObject *self, PyObject *args, PyObject *kwargs) { return 0; } + + static PyObject *callbackmcdataarrayint___new__(PyTypeObject *type, PyObject *args, PyObject *kwargs) + { + PyCallBackDataArrayInt *self = (PyCallBackDataArrayInt *) ( type->tp_alloc(type, 0) ); + return (PyObject *)self; + } + + static PyObject *callbackmcdataarraydouble___new__(PyTypeObject *type, PyObject *args, PyObject *kwargs) + { + PyCallBackDataArrayDouble *self = (PyCallBackDataArrayDouble *) ( type->tp_alloc(type, 0) ); + return (PyObject *)self; + } + + static void callbackmcdataarray_dealloc(PyObject *self) + { + Py_TYPE(self)->tp_free(self); + } + + static PyObject *callbackmcdataarrayint_call(PyCallBackDataArrayInt *self, PyObject *args, PyObject *kw) + { + if(self->_pt_mc) + { + ParaMEDMEM::MemArray& mma=self->_pt_mc->accessToMemArray(); + mma.destroy(); + } + Py_XINCREF(Py_None); + return Py_None; + } + + static PyObject *callbackmcdataarraydouble_call(PyCallBackDataArrayDouble *self, PyObject *args, PyObject *kw) + { + if(self->_pt_mc) + { + ParaMEDMEM::MemArray& mma=self->_pt_mc->accessToMemArray(); + mma.destroy(); + } + Py_XINCREF(Py_None); + return Py_None; + } +} + +PyTypeObject PyCallBackDataArrayInt_RefType = { + PyVarObject_HEAD_INIT(&PyType_Type, 0) + "callbackmcdataarrayint", + sizeof(PyCallBackDataArrayInt), + 0, + callbackmcdataarray_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + (ternaryfunc)callbackmcdataarrayint_call, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + callbackmcdataarray___init__, /*tp_init*/ + PyType_GenericAlloc, /*tp_alloc*/ + callbackmcdataarrayint___new__, /*tp_new*/ + PyObject_GC_Del, /*tp_free*/ +}; + +PyTypeObject PyCallBackDataArrayDouble_RefType = { + PyVarObject_HEAD_INIT(&PyType_Type, 0) + "callbackmcdataarraydouble", + sizeof(PyCallBackDataArrayDouble), + 0, + callbackmcdataarray_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + (ternaryfunc)callbackmcdataarraydouble_call, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + callbackmcdataarray___init__, /*tp_init*/ + PyType_GenericAlloc, /*tp_alloc*/ + callbackmcdataarraydouble___new__, /*tp_new*/ + PyObject_GC_Del, /*tp_free*/ +}; + +template +void numarrdeal2(void *pt, void *obj) +{ + typedef struct PyCallBackDataArraySt PyCallBackDataArray; + void **obj1=(void **)obj; + PyCallBackDataArray *cbdaic=reinterpret_cast(obj1[0]); + PyObject *weakRefOnOwner=reinterpret_cast(obj1[1]); + cbdaic->_pt_mc=0; + Py_XDECREF(weakRefOnOwner); + Py_XDECREF(cbdaic); + delete [] obj1; +} + +template +MCData *BuildNewInstance(PyObject *elt0, int npyObjectType, PyTypeObject *pytype, const char *msg) +{ + int ndim=PyArray_NDIM(elt0); + if(ndim!=1) + throw INTERP_KERNEL::Exception("Input numpy array has not 1 dimension !");//to do 1 or 2. + if(PyArray_ObjectType(elt0,0)!=npyObjectType) + { + std::ostringstream oss; oss << "Input numpy array has not of type " << msg << " !"; + throw INTERP_KERNEL::Exception(oss.str().c_str());//to do 1 or 2. + } + npy_intp stride=PyArray_STRIDE(elt0,0); + int itemSize=PyArray_ITEMSIZE(elt0); + if(itemSize ret=MCData::New(); + if(PyArray_ISBEHAVED(elt0))//aligned and writeable and in machine byte-order + { + PyArrayObject *elt0C=reinterpret_cast(elt0); + PyArrayObject *eltOwning=(PyArray_FLAGS(elt0C) & NPY_OWNDATA)?elt0C:NULL; + int mask=NPY_OWNDATA; mask=~mask; + elt0C->flags&=mask; + PyObject *deepestObj=elt0; + PyObject *base=elt0C->base; + if(base) deepestObj=base; + while(base) + { + if(PyArray_Check(base)) + { + PyArrayObject *baseC=reinterpret_cast(base); + eltOwning=(PyArray_FLAGS(baseC) & NPY_OWNDATA)?baseC:eltOwning; + baseC->flags&=mask; + base=baseC->base; + if(base) deepestObj=base; + } + else + break; + } + typename ParaMEDMEM::MemArray& mma=ret->accessToMemArray(); + if(eltOwning==NULL) + { + PyCallBackDataArraySt *cb=PyObject_GC_New(PyCallBackDataArraySt,pytype); + cb->_pt_mc=ret; + ret->useArray(reinterpret_cast(data),true,ParaMEDMEM::C_DEALLOC,sz,1); + PyObject *ref=PyWeakref_NewRef(deepestObj,(PyObject *)cb); + void **objs=new void *[2]; objs[0]=cb; objs[1]=ref; + mma.setParameterForDeallocator(objs); + mma.setSpecificDeallocator(numarrdeal2); + //"Impossible to share this numpy array chunk of data, because already shared by an another non numpy array object (maybe an another DataArrayInt instance) ! Release it, or perform a copy on the input array !"); + } + else + { + ret->useArray(reinterpret_cast(data),true,ParaMEDMEM::C_DEALLOC,sz,1); + PyObject *ref=PyWeakref_NewRef(reinterpret_cast(eltOwning),NULL); + void **objs=new void *[2]; objs[0]=ref; objs[1]=(void*) ParaMEDMEM::MemArray::CDeallocator; + mma.setParameterForDeallocator(objs); + mma.setSpecificDeallocator(numarrdeal); + } + } + else if(PyArray_ISBEHAVED_RO(elt0)) + ret->useArray(reinterpret_cast(data),false,ParaMEDMEM::CPP_DEALLOC,sz,1); + return ret.retn(); +} + +template +PyObject *ToNumPyArray(MCData *self, int npyObjectType, const char *MCDataStr) +{ + if(!self->isAllocated()) + { + std::ostringstream oss; oss << MCDataStr << "::toNumPyArray : this is not allocated !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); + } + ParaMEDMEM::MemArray& mem=self->accessToMemArray(); + int nbComp=self->getNumberOfComponents(); + if(nbComp!=1 && nbComp!=2) + { + std::ostringstream oss; oss << MCDataStr << "::toNumPyArray : number of components of this is " << nbComp << " ! Should 1 or 2 !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); + } + std::size_t sz=self->getNbOfElems(); + npy_intp dim[2]; + dim[0]=(npy_intp)self->getNumberOfTuples(); dim[1]=2; + const T *bg=self->getConstPointer(); + PyObject *ret=PyArray_SimpleNewFromData(nbComp,dim,npyObjectType,const_cast(bg)); + if(mem.isDeallocatorCalled()) + { + if(mem.getDeallocator()!=ParaMEDMEM::MemArray::CDeallocator) + { + int mask=NPY_OWNDATA; mask=~mask; + (reinterpret_cast(ret))->flags&=mask; + return ret; + } + else + { + PyObject *ref=PyWeakref_NewRef(ret,NULL); + void **objs=new void *[2]; objs[0]=ref; objs[1]=(void*) ParaMEDMEM::MemArray::CDeallocator; + mem.setParameterForDeallocator(objs); + mem.setSpecificDeallocator(numarrdeal); + return ret; + } + } + return ret; +} + #endif static PyObject *convertMesh(ParaMEDMEM::MEDCouplingMesh *mesh, int owner) throw(INTERP_KERNEL::Exception) @@ -81,33 +365,19 @@ static PyObject* convertMultiFields(ParaMEDMEM::MEDCouplingMultiFields *mfs, int static PyObject *convertIntArrToPyList(const int *ptr, int size) throw(INTERP_KERNEL::Exception) { -#ifndef WITH_NUMPY2 PyObject *ret=PyList_New(size); for(int i=0;i(tmp)); -#endif } static PyObject *convertIntArrToPyList2(const std::vector& v) throw(INTERP_KERNEL::Exception) { -#ifndef WITH_NUMPY2 int size=v.size(); PyObject *ret=PyList_New(size); for(int i=0;i& v) throw(INTERP_KERNEL::Exception) @@ -177,21 +447,7 @@ static int *convertPyToNewIntArr2(PyObject *pyLi, int *size) throw(INTERP_KERNEL } else { -#ifndef WITH_NUMPY2 throw INTERP_KERNEL::Exception("convertPyToNewIntArr2 : not a list"); -#else - if(PyArray_Check(pyLi)) - { - npy_intp mySize = PyArray_SIZE(pyLi); - int *ret=(int *)PyArray_BYTES(pyLi); - *size=mySize; - return ret; - } - else - { - throw INTERP_KERNEL::Exception("convertPyToNewIntArr2 : not a list nor PyArray"); - } -#endif } } @@ -288,20 +544,7 @@ static void convertPyToNewIntArr3(PyObject *pyLi, std::vector& arr) throw(I } else { -#ifndef WITH_NUMPY2 throw INTERP_KERNEL::Exception("convertPyToNewIntArr3 : not a list nor a tuple"); -#else - if(PyArray_Check(pyLi)) - { - npy_intp mySize = PyArray_SIZE(pyLi); - int *ret=(int *)PyArray_BYTES(pyLi); - arr.resize(mySize); - std::copy(ret,ret+mySize,arr.begin()); - return ; - } - else - throw INTERP_KERNEL::Exception("convertPyToNewIntArr3 : not a list nor a tuple nor PyArray"); -#endif } } diff --git a/src/MEDCoupling_Swig/Makefile.am b/src/MEDCoupling_Swig/Makefile.am index 52150f59e..bc06eea25 100644 --- a/src/MEDCoupling_Swig/Makefile.am +++ b/src/MEDCoupling_Swig/Makefile.am @@ -58,7 +58,7 @@ _MEDCouplingRemapper_la_LDFLAGS = -module $(PYTHON_LIBS) \ CLEANFILES = MEDCouplingWRAP.cxx MEDCoupling.py MEDCouplingRemapperWRAP.cxx MEDCouplingRemapper.py -dist_salomescript_DATA= MEDCouplingBasicsTest.py MEDCouplingRemapperTest.py MEDCoupling.py MEDCouplingRemapper.py MEDCouplingDataForTest.py libMEDCoupling_Swig.py +dist_salomescript_DATA= MEDCouplingBasicsTest.py MEDCouplingRemapperTest.py MEDCoupling.py MEDCouplingRemapper.py MEDCouplingDataForTest.py MEDCouplingNumpyTest.py libMEDCoupling_Swig.py UNIT_TEST_PROG = MEDCouplingBasicsTest.py MEDCouplingRemapperTest.py diff --git a/src/MEDLoader/MEDFileMesh.cxx b/src/MEDLoader/MEDFileMesh.cxx index 6c583f5c4..be85b93ba 100644 --- a/src/MEDLoader/MEDFileMesh.cxx +++ b/src/MEDLoader/MEDFileMesh.cxx @@ -214,9 +214,9 @@ std::vector MEDFileMesh::getFamiliesOnGroup(const char *name) const { std::string oname(name); std::map >::const_iterator it=_groups.find(oname); - std::vector grps=getGroupsNames(); if(it==_groups.end()) { + std::vector grps=getGroupsNames(); std::ostringstream oss; oss << "No such groupname \"" << name << "\" !\nAvailable groups are :"; std::copy(grps.begin(),grps.end(),std::ostream_iterator(oss," ")); throw INTERP_KERNEL::Exception(oss.str().c_str()); diff --git a/src/MEDLoader/Swig/CMakeLists.txt b/src/MEDLoader/Swig/CMakeLists.txt index 98919949d..f72dfc8d0 100644 --- a/src/MEDLoader/Swig/CMakeLists.txt +++ b/src/MEDLoader/Swig/CMakeLists.txt @@ -25,6 +25,9 @@ INCLUDE(${SWIG_USE_FILE}) SET_SOURCE_FILES_PROPERTIES(MEDLoader.i PROPERTIES CPLUSPLUS ON) SET_SOURCE_FILES_PROPERTIES(MEDLoader.i PROPERTIES SWIG_DEFINITIONS "-shadow") +IF(NUMPY_STATUS) + SET(SWIG_MODULE_MEDLoader_EXTRA_FLAGS -DWITH_NUMPY) +ENDIF(NUMPY_STATUS) SET (MEDLoader_SWIG_DPYS_FILES MEDLoaderCommon.i @@ -52,7 +55,7 @@ SET (SWIG_MODULE_MEDLoader_EXTRA_DEPS ${MEDLoader_SWIG_DPYS_FILES} SWIG_ADD_MODULE(MEDLoader python MEDLoader.i) SWIG_LINK_LIBRARIES(MEDLoader ${PYTHON_LIBS} ${PLATFORM_LIBS} medloader medcoupling) -SET_TARGET_PROPERTIES(_MEDLoader PROPERTIES COMPILE_FLAGS "${PLATFORM_DEFINITIONS}") +SET_TARGET_PROPERTIES(_MEDLoader PROPERTIES COMPILE_FLAGS "${PLATFORM_DEFINITIONS} ${PYTHON_DEFINITIONS}") IF(${MACHINE} STREQUAL WINDOWS) SET_TARGET_PROPERTIES(_MEDLoader PROPERTIES DEBUG_OUTPUT_NAME _MEDLoader_d) ENDIF(${MACHINE} STREQUAL WINDOWS) @@ -63,8 +66,7 @@ INSTALL(FILES MEDLoader.i MEDLoaderTypemaps.i MEDLoaderCommon.i DESTINATION ${ME SET(PYFILES_TO_INSTALL ${CMAKE_CURRENT_BINARY_DIR}/MEDLoader.py ${CMAKE_CURRENT_SOURCE_DIR}/libMEDLoader_Swig.py) INSTALL_AND_COMPILE_PYTHON_FILE("${PYFILES_TO_INSTALL}" ${MED_salomescript_PYTHON}) -INSTALL(FILES MEDLoaderDataForTest.py MEDLoaderTest.py MEDLoaderTest2.py MEDLoaderTest3.py medutilities.py DESTINATION ${MED_salomescript_PYTHON}) -INSTALL(FILES med2sauv sauv2med PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ DESTINATION ${MED_salomescript_PYTHON} ) +INSTALL(FILES MEDLoaderDataForTest.py MEDLoaderTest.py MEDLoaderTest2.py MEDLoaderTest3.py DESTINATION ${MED_salomescript_PYTHON}) ADD_TEST(MEDLoaderTest ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/MEDLoaderTest.py) ADD_TEST(MEDLoaderTest2 ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/MEDLoaderTest2.py) diff --git a/src/MEDLoader/Test/SauvLoaderTest.cxx b/src/MEDLoader/Test/SauvLoaderTest.cxx index f1c8f8d0d..084532db0 100644 --- a/src/MEDLoader/Test/SauvLoaderTest.cxx +++ b/src/MEDLoader/Test/SauvLoaderTest.cxx @@ -58,24 +58,23 @@ void SauvLoaderTest::testMed2SauvOnAMeshWithVoidFamily() const int nbOfNodes = 6; double coords[nbOfNodes*spaceDim] = {0,0, 1,0, 1,1, 0,1, 2,0, 2,1}; int conn[8]={0,1,2,3, 1,4,5,2}; - MEDCouplingUMesh *mesh2d=MEDCouplingUMesh::New("Mesh",spaceDim); + MEDCouplingAutoRefCountObjectPtr mesh2d=MEDCouplingUMesh::New("Mesh",spaceDim); mesh2d->allocateCells(2); mesh2d->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,conn); mesh2d->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,conn+4); mesh2d->finishInsertingCells(); - DataArrayDouble *myCoords=DataArrayDouble::New(); + MEDCouplingAutoRefCountObjectPtr myCoords=DataArrayDouble::New(); myCoords->alloc(nbOfNodes,spaceDim); std::copy(coords,coords+nbOfNodes*spaceDim,myCoords->getPointer()); mesh2d->setCoords(myCoords); - myCoords->decrRef(); // create a MedFileUMesh - MEDFileUMesh* m= MEDFileUMesh::New(); + MEDCouplingAutoRefCountObjectPtr m= MEDFileUMesh::New(); m->setMeshAtLevel(0,mesh2d); // Create families and groups - DataArrayInt *fam = DataArrayInt::New(); + MEDCouplingAutoRefCountObjectPtr fam = DataArrayInt::New(); fam->alloc(2,1); int elemsFams[2] = {-2,-3}; std::copy(elemsFams,elemsFams+2,fam->getPointer()); @@ -102,9 +101,9 @@ void SauvLoaderTest::testMed2SauvOnAMeshWithVoidFamily() // write to SAUV const char* sauvFile = "mesh_with_void_family.sauv"; - MEDFileData* medData = MEDFileData::New(); - MEDFileMeshes* medMeshes = MEDFileMeshes::New(); - SauvWriter* sw=SauvWriter::New(); + MEDCouplingAutoRefCountObjectPtr medData = MEDFileData::New(); + MEDCouplingAutoRefCountObjectPtr medMeshes = MEDFileMeshes::New(); + MEDCouplingAutoRefCountObjectPtr sw=SauvWriter::New(); medMeshes->setMeshAtPos(0, m); medData->setMeshes(medMeshes); sw->setMEDFileDS(medData); @@ -113,27 +112,58 @@ void SauvLoaderTest::testMed2SauvOnAMeshWithVoidFamily() // read SAUV and check groups MEDCouplingAutoRefCountObjectPtr sr=SauvReader::New(sauvFile); MEDCouplingAutoRefCountObjectPtr d2=sr->loadInMEDFileDS(); - MEDFileUMesh * m2 = static_cast( d2->getMeshes()->getMeshAtPos(0) ); - std::vector groups = m->getGroupsNames(); - std::cout << "Number of groups: " << groups.size() << std::endl; - CPPUNIT_ASSERT_EQUAL(3,(int)groups.size()); - MEDCouplingUMesh * grp1 = m2->getGroup(0, "Group1"); + MEDFileUMesh* m2 = static_cast( d2->getMeshes()->getMeshAtPos(0) ); + MEDCouplingAutoRefCountObjectPtr grp1 = m2->getGroup(0, "Group1"); CPPUNIT_ASSERT_EQUAL(1,(int)grp1->getNumberOfCells()); - MEDCouplingUMesh * grp2 = m2->getGroup(0, "Group2"); + MEDCouplingAutoRefCountObjectPtr grp2 = m2->getGroup(0, "Group2"); CPPUNIT_ASSERT_EQUAL(1,(int)grp2->getNumberOfCells()); - MEDCouplingUMesh * grptot = m2->getGroup(0, "Grouptot"); + MEDCouplingAutoRefCountObjectPtr grptot = m2->getGroup(0, "Grouptot"); CPPUNIT_ASSERT_EQUAL(2,(int)grptot->getNumberOfCells()); +} - // clean - mesh2d->decrRef(); - medData->decrRef(); - medMeshes->decrRef(); - fam->decrRef(); - m->decrRef(); - sw->decrRef(); - grp1->decrRef(); - grp2->decrRef(); - grptot->decrRef(); +void SauvLoaderTest::testSauv2MedOnA3SubsField() +{ + // read SAUV + std::string sauvFile = getResourceFile("portico_3subs.sauv"); + MEDCouplingAutoRefCountObjectPtr sr=SauvReader::New(sauvFile.c_str()); + MEDCouplingAutoRefCountObjectPtr d2=sr->loadInMEDFileDS(); + // check mesh + MEDFileUMesh* m2 = static_cast(d2->getMeshes()->getMeshAtPos(0)); + MEDCouplingAutoRefCountObjectPtr mesh1d = m2->getMeshAtLevel(0); + MEDCouplingAutoRefCountObjectPtr length1dField = mesh1d->getMeasureField(0); + std::cout << "Length of 1d elements: " << length1dField->accumulate(0) << std::endl; + CPPUNIT_ASSERT_DOUBLES_EQUAL(3, length1dField->accumulate(0), 1e-12); + // check field + MEDCouplingAutoRefCountObjectPtr field = + d2->getFields()->getFieldWithName("CHAM1D"); + std::cout << "Number of components in field: " << field->getInfo().size() << std::endl; + CPPUNIT_ASSERT_EQUAL(6,(int)field->getInfo().size()); + std::vector< std::pair > timesteps = field->getIterations(); + + MEDCouplingAutoRefCountObjectPtr field1d = + field->getFieldOnMeshAtLevel(ON_GAUSS_NE, timesteps[0].first, timesteps[0].second, 0, m2); + + // Check first component of the field + // 2 gauss points per element => 12 values + double values[12] = { + -7.687500000000e-03, + -7.687500000000e-03, + -4.562500000000e-03, + -4.562500000000e-03, + -8.208333333333e-03, + -8.208333333333e-03, + -6.125000000000e-03, + -6.125000000000e-03, + -4.041666666666e-03, + -4.041666666666e-03, + -6.111413346910e-07, + -6.111413346910e-07}; + + for (int i=0; i < field1d->getNumberOfTuples(); i++) + { + bool ok = abs(values[i]-field1d->getIJ(i, 0)) < 1e-12; + CPPUNIT_ASSERT_DOUBLES_EQUAL( values[i], field1d->getIJ(i, 0), 1e-12 ); + } } void SauvLoaderTest::testMed2Sauv() diff --git a/src/MEDLoader/Test/SauvLoaderTest.hxx b/src/MEDLoader/Test/SauvLoaderTest.hxx index a43d1299c..3764dde60 100644 --- a/src/MEDLoader/Test/SauvLoaderTest.hxx +++ b/src/MEDLoader/Test/SauvLoaderTest.hxx @@ -32,11 +32,13 @@ namespace ParaMEDMEM CPPUNIT_TEST( testSauv2Med ); CPPUNIT_TEST( testMed2Sauv ); CPPUNIT_TEST( testMed2SauvOnAMeshWithVoidFamily ); + CPPUNIT_TEST( testSauv2MedOnA3SubsField ); CPPUNIT_TEST_SUITE_END(); public: void testSauv2Med(); void testMed2Sauv(); void testMed2SauvOnAMeshWithVoidFamily(); + void testSauv2MedOnA3SubsField(); public: void tearDown(); diff --git a/src/ParaMEDMEM_Swig/CMakeLists.txt b/src/ParaMEDMEM_Swig/CMakeLists.txt index f662071f3..5cacdcb4f 100644 --- a/src/ParaMEDMEM_Swig/CMakeLists.txt +++ b/src/ParaMEDMEM_Swig/CMakeLists.txt @@ -23,6 +23,9 @@ INCLUDE(${SWIG_USE_FILE}) SET_SOURCE_FILES_PROPERTIES(ParaMEDMEM.i PROPERTIES CPLUSPLUS ON) SET_SOURCE_FILES_PROPERTIES(ParaMEDMEM.i PROPERTIES SWIG_DEFINITIONS "-shadow") +IF(NUMPY_STATUS) + SET(SWIG_MODULE_ParaMEDMEM_EXTRA_FLAGS -DWITH_NUMPY) +ENDIF(NUMPY_STATUS) SET (ParaMEDMEM_SWIG_DPYS_FILES ParaMEDMEM.typemap) @@ -53,6 +56,10 @@ SWIG_LINK_LIBRARIES(ParaMEDMEM ${PYTHON_LIBS} paramedmem medloader) SET_SOURCE_FILES_PROPERTIES(ParaMEDMEM.i PROPERTIES CPLUSPLUS ON) SET_SOURCE_FILES_PROPERTIES(ParaMEDMEM.i PROPERTIES SWIG_DEFINITIONS "-shadow") +IF(NUMPY_STATUS) + SET(SWIG_MODULE_ParaMEDMEM_EXTRA_FLAGS -DWITH_NUMPY) +ENDIF(NUMPY_STATUS) +SET_TARGET_PROPERTIES(${SWIG_MODULE_ParaMEDMEM_REAL_NAME} PROPERTIES COMPILE_FLAGS "${PLATFORM_DEFINITIONS} ${PYTHON_DEFINITIONS}") INSTALL(TARGETS _ParaMEDMEM DESTINATION ${MED_salomepythondir}) INSTALL(FILES ParaMEDMEM.i DESTINATION ${MED_salomeinclude_HEADERS}) -- 2.30.2

Writting fields in a VTK file

Getting maximal and minimal fields

Concatenating fields

Subtracting field on different meshs

Changing the underlying mesh

Changing a field using a formular

Changing a field using a formular

Changing a field using a formular

Changing a field using a formular

Filling a field with a value

Filling a field using a formular

Filling a field using a formular

Filling a field using a formular

Getting a field value at some point at certain time

Getting field values at some points

Getting a field value at a point

Getting a value of field lying on a structured mesh

Permuting a field on nodes

Permuting a field on cells

Getting a field copy with different time discretization