--- /dev/null
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+
+// This file contains some code used only for
+// * generation of documentation for inline methods,
+// * groupping methods into "Basic API", "Advanced" and "Others..." sections
+
+
+namespace ParaMEDMEM
+{
+ /*!
+ * Returns a new MEDCouplingFieldDouble containing sum values of corresponding values of
+ * \a this and a given field ( _f_ [ i, j ] = _this_ [ i, j ] + _other_ [ i, j ] ).
+ * Number of tuples and components in the two fields must be the same.
+ * \param [in] other - the input 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 the fields are not strictly compatible (areStrictlyCompatible()), i.e. they
+ * differ not only in values.
+ */
+ MEDCouplingFieldDouble *MEDCouplingFieldDouble::operator+(const MEDCouplingFieldDouble& other) const throw(INTERP_KERNEL::Exception) {}
+ /*!
+ * Returns a new MEDCouplingFieldDouble containing subtraction of corresponding values of
+ * \a this and a given field ( _f_ [ i, j ] = _this_ [ i, j ] - _other_ [ i, j ] ).
+ * Number of tuples and components in the two fields must be the same.
+ * \param [in] other - the field to subtract from \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 the fields are not strictly compatible (areStrictlyCompatible()), i.e. they
+ * differ not only in values.
+ */
+ MEDCouplingFieldDouble *MEDCouplingFieldDouble::operator-(const MEDCouplingFieldDouble& other) const throw(INTERP_KERNEL::Exception) {}
+ /*!
+ * Returns a new MEDCouplingFieldDouble containing product values of \a this and a
+ * given field. 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 _this_ and
+ * _other_, i.e. _f_ [ i, j ] = _this_ [ i, j ] * _other_ [ i, j ].
+ * 2. The fields have same number of tuples and one field, say _other_, has one
+ * component. Then
+ * _f_ [ i, j ] = _this_ [ i, j ] * _other_ [ i, 0 ].
+ *
+ * The two fields must have same number of tuples and same underlying mesh.
+ * \param [in] other - a 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 the fields are not compatible for production (areCompatibleForMul()),
+ * i.e. they differ not only in values and possibly number of components.
+ */
+ MEDCouplingFieldDouble *MEDCouplingFieldDouble::operator*(const MEDCouplingFieldDouble& other) const throw(INTERP_KERNEL::Exception) {}
+ /*!
+ * Returns a new MEDCouplingFieldDouble containing division of \a this and a given
+ * field. 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 this and
+ * \a other, i.e. _f_ [ i, j ] = _this_ [ i, j ] / _other_ [ i, j ].
+ * 2. The fields have same number of tuples and _other_ has one component. Then
+ * _f_ [ i, j ] = _this_ [ i, j ] / _other_ [ i, 0 ].
+ *
+ * \param [in] other - 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 the fields are not compatible for division (areCompatibleForDiv()),
+ * i.e. they differ not only in values and possibly in number of components.
+ */
+ MEDCouplingFieldDouble *MEDCouplingFieldDouble::operator/(const MEDCouplingFieldDouble& other) const throw(INTERP_KERNEL::Exception) {}
+ /*!
+ * Returns a new MEDCouplingFieldDouble containing a dot product of \a this and a given field,
+ * so that the i-th tuple of the result field (_f_) is a sum of products of j-th components of
+ * i-th tuples of two fields (\f$ f_i = \sum_ {}^n f1_j * f2_j \f$).
+ * Number of tuples and components in the two fields must be the same.
+ * \param [in] other - the input 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 the fields are not strictly compatible (areStrictlyCompatible()), i.e. they
+ * differ not only in values.
+ */
+ MEDCouplingFieldDouble *MEDCouplingFieldDouble::dot(const MEDCouplingFieldDouble& other) const throw(INTERP_KERNEL::Exception) {}
+ /*!
+ * Returns a new MEDCouplingFieldDouble containing a cross product of \a this and
+ * a given field, 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 the two fields.
+ * Number of tuples in the fields must be the same.
+ * Number of components in the fields must be 3.
+ * \param [in] other - the input 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 \a this->getNumberOfComponents() != 3
+ * \throw If \a other->getNumberOfComponents() != 3
+ * \throw If the fields are not strictly compatible (areStrictlyCompatible()), i.e. they
+ * differ not only in values.
+ */
+ MEDCouplingFieldDouble *MEDCouplingFieldDouble::crossProduct(const MEDCouplingFieldDouble& other) const throw(INTERP_KERNEL::Exception) {}
+ /*!
+ * Returns a new MEDCouplingFieldDouble containing maximal values of \a this and a
+ * given field. Number of tuples and components in the two fields must be the same.
+ * \param [in] other - the field to compare values with \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 the fields are not strictly compatible (areStrictlyCompatible()), i.e. they
+ * differ not only in values.
+ */
+ MEDCouplingFieldDouble *MEDCouplingFieldDouble::max(const MEDCouplingFieldDouble& other) const throw(INTERP_KERNEL::Exception) {}
+ /*!
+ * Returns a new MEDCouplingFieldDouble containing minimal values of \a this and a
+ * given field. Number of tuples and components in the two fields must be the same.
+ * \param [in] other - the field to compare values with \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 the fields are not strictly compatible (areStrictlyCompatible()), i.e. they
+ * differ not only in values.
+ */
+ MEDCouplingFieldDouble *MEDCouplingFieldDouble::min(const MEDCouplingFieldDouble& other) const throw(INTERP_KERNEL::Exception) {}
+ /*!
+ * Returns the data array of \a this field.
+ * \return const DataArrayDouble * - a const pointer to the data array of \a this field.
+ */
+ const DataArrayDouble *MEDCouplingFieldDouble::getArray() const {}
+ /*!
+ * Returns the data array of \a this field apt for modification.
+ * \return DataArrayDouble * - a non-const pointer to the data array of \a this field.
+ */
+ DataArrayDouble *MEDCouplingFieldDouble::getArray() {}
+ /*!
+ * Sets a precision used to compare time values.
+ * \param [in] val - the precision value.
+ */
+ void MEDCouplingFieldDouble::setTimeTolerance(double val) {}
+ /*!
+ * Returns a precision used to compare time values.
+ * \return double - the precision value.
+ */
+ double MEDCouplingFieldDouble::getTimeTolerance() const {}
+ /*!
+ * Sets the number of iteration where the data array of \a this field has been calculated.
+ * For examples of field construction, see \ref MEDCouplingFirstSteps3.
+ * \param [in] it - the iteration number.
+ */
+ void MEDCouplingFieldDouble::setIteration(int it) throw(INTERP_KERNEL::Exception) {}
+ /*!
+ * Sets the number of iteration where the second data array of \a this field has been calculated.
+ * For examples of field construction, see \ref MEDCouplingFirstSteps3.
+ * \param [in] it - the iteration number.
+ */
+ void MEDCouplingFieldDouble::setEndIteration(int it) throw(INTERP_KERNEL::Exception) {}
+ /*!
+ * Sets the order number of iteration where the data array of \a this field has been calculated.
+ * For examples of field construction, see \ref MEDCouplingFirstSteps3.
+ * \param [in] order - the order number.
+ */
+ void MEDCouplingFieldDouble::setOrder(int order) throw(INTERP_KERNEL::Exception) {}
+ /*!
+ * Sets the order number of iteration where the second data array of \a this field has
+ * been calculated.
+ * \param [in] order - the order number.
+ */
+ void MEDCouplingFieldDouble::setEndOrder(int order) throw(INTERP_KERNEL::Exception) {}
+ /*!
+ * Sets the time when the data array of \a this field has been calculated.
+ * For examples of field construction, see \ref MEDCouplingFirstSteps3.
+ * \param [in] val - the time value.
+ */
+ void MEDCouplingFieldDouble::setTimeValue(double val) throw(INTERP_KERNEL::Exception) {}
+ /*!
+ * Sets the time when the second data array of \a this field has been calculated.
+ * \param [in] val - the time value.
+ */
+ void MEDCouplingFieldDouble::setEndTimeValue(double val) throw(INTERP_KERNEL::Exception) {}
+ /*!
+ * Sets time, number of iteration and order number of iteration when the data array
+ * of \a this field has been calculated.
+ * For examples of field construction, see \ref MEDCouplingFirstSteps3.
+ * \param [in] val - the time value.
+ * \param [in] iteration - the iteration number.
+ * \param [in] order - the order number.
+ */
+ void MEDCouplingFieldDouble::setTime(double val, int iteration, int order) {}
+ /*!
+ * Returns time, number of iteration and order number of iteration when the data array
+ * of \a this field has been calculated.
+ * For examples of field construction, see \ref MEDCouplingFirstSteps3.
+ * \param [out] iteration - the iteration number.
+ * \param [out] order - the order number.
+ * \return double - the time value.
+ */
+ double MEDCouplingFieldDouble::getTime(int& iteration, int& order) const {}
+ /*!
+ * Returns a value indexed by a tuple id and a component id.
+ * \param [in] tupleId - the id of the tuple of interest.
+ * \param [in] compoId - the id of the component of interest.
+ * \return double - the field value.
+ */
+ double MEDCouplingFieldDouble::getIJ(int tupleId, int compoId) const {}
+}
+
+namespace ParaMEDMEM
+{
+/*! \name Basic API */
+///@{
+MEDCouplingFieldDouble::AddFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2);
+MEDCouplingFieldDouble::CrossProductFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2);
+MEDCouplingFieldDouble::DivideFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2);
+MEDCouplingFieldDouble::DotFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2);
+MEDCouplingFieldDouble::MaxFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2);
+MEDCouplingFieldDouble::MeldFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2);
+MEDCouplingFieldDouble::MergeFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2);
+MEDCouplingFieldDouble::MergeFields(const std::vector<const MEDCouplingFieldDouble *>& a);
+MEDCouplingFieldDouble::MinFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2);
+MEDCouplingFieldDouble::MultiplyFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2);
+MEDCouplingFieldDouble::New(TypeOfField type, TypeOfTimeDiscretization td=ONE_TIME);
+MEDCouplingFieldDouble::New(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td=ONE_TIME);
+MEDCouplingFieldDouble::SubstractFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2);
+MEDCouplingFieldDouble::WriteVTK(const char *fileName, const std::vector<const MEDCouplingFieldDouble *>& fs);
+MEDCouplingFieldDouble::accumulate(double *res) const;
+MEDCouplingFieldDouble::accumulate(int compId) const;
+MEDCouplingFieldDouble::advancedRepr() const;
+MEDCouplingFieldDouble::applyFunc(const char *func);
+MEDCouplingFieldDouble::applyFunc(int nbOfComp, FunctionToEvaluate func);
+MEDCouplingFieldDouble::applyFunc(int nbOfComp, const char *func);
+MEDCouplingFieldDouble::applyFunc(int nbOfComp, double val);
+MEDCouplingFieldDouble::applyFunc2(int nbOfComp, const char *func);
+MEDCouplingFieldDouble::applyFunc3(int nbOfComp, const std::vector<std::string>& varsOrder, const char *func);
+MEDCouplingFieldDouble::applyLin(double a, double b, int compoId);
+MEDCouplingFieldDouble::buildNewTimeReprFromThis(TypeOfTimeDiscretization td, bool deepCopy) const;
+MEDCouplingFieldDouble::buildSubPart(const DataArrayInt *part) const;
+MEDCouplingFieldDouble::buildSubPart(const int *partBg, const int *partEnd) const;
+MEDCouplingFieldDouble::changeNbOfComponents(int newNbOfComp, double dftValue=0.);
+MEDCouplingFieldDouble::changeUnderlyingMesh(const MEDCouplingMesh *other, int levOfCheck, double precOnMesh, double eps=1e-15);
+MEDCouplingFieldDouble::checkCoherency() const;
+MEDCouplingFieldDouble::clone(bool recDeepCpy) const;
+MEDCouplingFieldDouble::cloneWithMesh(bool recDeepCpy) const;
+MEDCouplingFieldDouble::copyTinyAttrFrom(const MEDCouplingFieldDouble *other);
+MEDCouplingFieldDouble::copyTinyStringsFrom(const MEDCouplingField *other);
+MEDCouplingFieldDouble::crossProduct(const MEDCouplingFieldDouble& other) const;
+MEDCouplingFieldDouble::deepCpy() const;
+MEDCouplingFieldDouble::determinant() const;
+MEDCouplingFieldDouble::deviator() const;
+MEDCouplingFieldDouble::dot(const MEDCouplingFieldDouble& other) const;
+MEDCouplingFieldDouble::doublyContractedProduct() const;
+MEDCouplingFieldDouble::eigenValues() const;
+MEDCouplingFieldDouble::eigenVectors() const;
+MEDCouplingFieldDouble::fillFromAnalytic(int nbOfComp, FunctionToEvaluate func);
+MEDCouplingFieldDouble::fillFromAnalytic(int nbOfComp, const char *func);
+MEDCouplingFieldDouble::fillFromAnalytic2(int nbOfComp, const char *func);
+MEDCouplingFieldDouble::fillFromAnalytic3(int nbOfComp, const std::vector<std::string>& varsOrder, const char *func);
+MEDCouplingFieldDouble::getArray() const;
+MEDCouplingFieldDouble::getArray();
+MEDCouplingFieldDouble::getAverageValue() const;
+MEDCouplingFieldDouble::getIJ(int tupleId, int compoId) const;
+MEDCouplingFieldDouble::getIJK(int cellId, int nodeIdInCell, int compoId) const;
+MEDCouplingFieldDouble::getIdsInRange(double vmin, double vmax) const;
+MEDCouplingFieldDouble::getMaxValue() const;
+MEDCouplingFieldDouble::getMaxValue2(DataArrayInt*& tupleIds) const;
+MEDCouplingFieldDouble::getMinValue() const;
+MEDCouplingFieldDouble::getMinValue2(DataArrayInt*& tupleIds) const;
+MEDCouplingFieldDouble::getNumberOfComponents() const;
+MEDCouplingFieldDouble::getNumberOfTuples() const;
+MEDCouplingFieldDouble::getNumberOfValues() const;
+MEDCouplingFieldDouble::getTime(int& iteration, int& order) const;
+MEDCouplingFieldDouble::getTimeDiscretization() const;
+MEDCouplingFieldDouble::getTimeTolerance() const;
+MEDCouplingFieldDouble::getTimeUnit() const;
+MEDCouplingFieldDouble::getValueOn(const double *spaceLoc, double *res) const;
+MEDCouplingFieldDouble::getValueOn(const double *spaceLoc, double time, double *res) const;
+MEDCouplingFieldDouble::getValueOnMulti(const double *spaceLoc, int nbOfPoints) const;
+MEDCouplingFieldDouble::getValueOnPos(int i, int j, int k, double *res) const;
+MEDCouplingFieldDouble::getWeightedAverageValue(double *res, bool isWAbs=true) const;
+MEDCouplingFieldDouble::getWeightedAverageValue(int compId, bool isWAbs=true) const;
+MEDCouplingFieldDouble::integral(bool isWAbs, double *res) const;
+MEDCouplingFieldDouble::integral(int compId, bool isWAbs) const;
+MEDCouplingFieldDouble::inverse() const;
+MEDCouplingFieldDouble::isEqualWithoutConsideringStr(const MEDCouplingField *other, double meshPrec, double valsPrec) const;
+MEDCouplingFieldDouble::keepSelectedComponents(const std::vector<int>& compoIds) const;
+MEDCouplingFieldDouble::magnitude() const;
+MEDCouplingFieldDouble::max(const MEDCouplingFieldDouble& other) const;
+MEDCouplingFieldDouble::maxPerTuple() const;
+MEDCouplingFieldDouble::mergeNodes(double eps, double epsOnVals=1e-15);
+MEDCouplingFieldDouble::mergeNodes2(double eps, double epsOnVals=1e-15);
+MEDCouplingFieldDouble::min(const MEDCouplingFieldDouble& other) const;
+MEDCouplingFieldDouble::norm2() const;
+MEDCouplingFieldDouble::normL1(double *res) const;
+MEDCouplingFieldDouble::normL1(int compId) const;
+MEDCouplingFieldDouble::normL2(double *res) const;
+MEDCouplingFieldDouble::normL2(int compId) const;
+MEDCouplingFieldDouble::normMax() const;
+MEDCouplingFieldDouble::renumberCells(const int *old2NewBg, bool check=true);
+MEDCouplingFieldDouble::renumberNodes(const int *old2NewBg, double eps=1e-15);
+MEDCouplingFieldDouble::setArray(DataArrayDouble *array);
+MEDCouplingFieldDouble::setArrays(const std::vector<DataArrayDouble *>& arrs);
+MEDCouplingFieldDouble::setEndArray(DataArrayDouble *array);
+MEDCouplingFieldDouble::setEndIteration(int it);
+MEDCouplingFieldDouble::setIteration(int it);
+MEDCouplingFieldDouble::setNature(NatureOfField nat);
+MEDCouplingFieldDouble::setOrder(int order);
+MEDCouplingFieldDouble::setSelectedComponents(const MEDCouplingFieldDouble *f, const std::vector<int>& compoIds);
+MEDCouplingFieldDouble::setTime(double val, int iteration, int order);
+MEDCouplingFieldDouble::setTimeTolerance(double val);
+MEDCouplingFieldDouble::setTimeUnit(const char *unit);
+MEDCouplingFieldDouble::setTimeValue(double val);
+MEDCouplingFieldDouble::simpleRepr() const;
+MEDCouplingFieldDouble::simplexize(int policy);
+MEDCouplingFieldDouble::sortPerTuple(bool asc);
+MEDCouplingFieldDouble::substractInPlaceDM(const MEDCouplingFieldDouble *f, int levOfCheck, double precOnMesh, double eps=1e-15);
+MEDCouplingFieldDouble::trace() const;
+MEDCouplingFieldDouble::updateTime() const;
+MEDCouplingFieldDouble::writeVTK(const char *fileName) const;
+MEDCouplingFieldDouble::zipConnectivity(int compType, double epsOnVals=1e-15);
+MEDCouplingFieldDouble::zipCoords(double epsOnVals=1e-15);
+ MEDCouplingFieldDouble & MEDCouplingFieldDouble::operator=(double value);
+ MEDCouplingFieldDouble * MEDCouplingFieldDouble::operator*(const MEDCouplingFieldDouble& other) const;
+ MEDCouplingFieldDouble * MEDCouplingFieldDouble::operator+(const MEDCouplingFieldDouble& other) const;
+ MEDCouplingFieldDouble * MEDCouplingFieldDouble::operator-(const MEDCouplingFieldDouble& other) const;
+ MEDCouplingFieldDouble * MEDCouplingFieldDouble::operator/(const MEDCouplingFieldDouble& other) const;
+ const MEDCouplingFieldDouble & MEDCouplingFieldDouble::operator*=(const MEDCouplingFieldDouble& other);
+ const MEDCouplingFieldDouble & MEDCouplingFieldDouble::operator+=(const MEDCouplingFieldDouble& other);
+ const MEDCouplingFieldDouble & MEDCouplingFieldDouble::operator-=(const MEDCouplingFieldDouble& other);
+ const MEDCouplingFieldDouble & MEDCouplingFieldDouble::operator/=(const MEDCouplingFieldDouble& other);
+///@}
+/*! \name Advanced API */
+///@{
+MEDCouplingFieldDouble::renumberCellsWithoutMesh(const int *old2NewBg, bool check=true);
+MEDCouplingFieldDouble::renumberNodesWithoutMesh(const int *old2NewBg, int newNbOfNodes, double eps=1e-15);
+///@}
+
+/*! \name Others... */
+///@{
+ MEDCouplingFieldDouble::negate() const;
+ MEDCouplingFieldDouble::operator^(const MEDCouplingFieldDouble& other) const;
+ MEDCouplingFieldDouble::operator^=(const MEDCouplingFieldDouble& other);
+ MEDCouplingFieldDouble::PowFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2);
+MEDCouplingFieldDouble::buildSubPartRange(int begin, int end, int step) const;
+MEDCouplingFieldDouble::MEDCouplingFieldDouble(NatureOfField n, MEDCouplingTimeDiscretization *td, MEDCouplingFieldDiscretization *type);
+MEDCouplingFieldDouble::MEDCouplingFieldDouble(TypeOfField type, TypeOfTimeDiscretization td);
+MEDCouplingFieldDouble::MEDCouplingFieldDouble(const MEDCouplingFieldDouble& other, bool deepCopy);
+MEDCouplingFieldDouble::MEDCouplingFieldDouble(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td);
+MEDCouplingFieldDouble::applyFuncFast32(const char *func);
+MEDCouplingFieldDouble::applyFuncFast64(const char *func);
+MEDCouplingFieldDouble::areCompatibleForDiv(const MEDCouplingField *other) const;
+MEDCouplingFieldDouble::areCompatibleForMeld(const MEDCouplingFieldDouble *other) const;
+MEDCouplingFieldDouble::areCompatibleForMerge(const MEDCouplingField *other) const;
+MEDCouplingFieldDouble::areCompatibleForMul(const MEDCouplingField *other) const;
+MEDCouplingFieldDouble::areStrictlyCompatible(const MEDCouplingField *other) const;
+MEDCouplingFieldDouble::copyAllTinyAttrFrom(const MEDCouplingFieldDouble *other);
+MEDCouplingFieldDouble::extractSlice3D(const double *origin, const double *vec, double eps) const;
+MEDCouplingFieldDouble::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<double>& tinyInfoD, const std::vector<std::string>& tinyInfoS);
+MEDCouplingFieldDouble::getArrays() const;
+MEDCouplingFieldDouble::getEndArray() const;
+MEDCouplingFieldDouble::getEndArray();
+MEDCouplingFieldDouble::getEndTime(int& iteration, int& order) const;
+MEDCouplingFieldDouble::getHeapMemorySize() const;
+MEDCouplingFieldDouble::getStartTime(int& iteration, int& order) const;
+MEDCouplingFieldDouble::getTimeDiscretizationUnderGround() const;
+MEDCouplingFieldDouble::getTimeDiscretizationUnderGround();
+MEDCouplingFieldDouble::getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const;
+MEDCouplingFieldDouble::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const;
+MEDCouplingFieldDouble::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const;
+MEDCouplingFieldDouble::isEqualIfNotWhy(const MEDCouplingField *other, double meshPrec, double valsPrec, std::string& reason) const;
+MEDCouplingFieldDouble::reprQuickOverview(std::ostream& stream) const;
+MEDCouplingFieldDouble::resizeForUnserialization(const std::vector<int>& tinyInfoI, DataArrayInt *&dataInt, std::vector<DataArrayDouble *>& arrays);
+MEDCouplingFieldDouble::serialize(DataArrayInt *&dataInt, std::vector<DataArrayDouble *>& arrays) const;
+MEDCouplingFieldDouble::setEndOrder(int order);
+MEDCouplingFieldDouble::setEndTime(double val, int iteration, int order);
+MEDCouplingFieldDouble::setEndTimeValue(double val);
+MEDCouplingFieldDouble::setStartTime(double val, int iteration, int order);
+MEDCouplingFieldDouble::synchronizeTimeWithMesh();
+MEDCouplingFieldDouble::synchronizeTimeWithSupport();
+MEDCouplingFieldDouble::~MEDCouplingFieldDouble();
+MEDCouplingFieldDouble::_time_discr;
+///@}
+}
\page medcouplingcppexamples MEDCoupling C++ examples
+\anchor cpp_mcfielddouble_WriteVTK
+<br><h2> Writting fields in a VTK file </h2>
-\anchor cpp_mcmesh_
-<br><h2> </h2>
+In this example we
+- create an 2D mesh and 3 fields on it,
+- use
+\ref ParaMEDMEM::MEDCouplingFieldDouble::WriteVTK "WriteVTK()"
+to write all the fields and the mesh to a VTK file.
+
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_WriteVTK_1
+
+
+
+\anchor cpp_mcfielddouble_MaxFields
+<br><h2> Getting maximal and minimal fields </h2>
+
+In this example we
+- create two fields with two tuples per two components,
+- use
+\ref ParaMEDMEM::MEDCouplingFieldDouble::MaxFields "MaxFields()"
+to get a field holding maximal values of the two fields.
+- use
+\ref ParaMEDMEM::MEDCouplingFieldDouble::MinFields "MinFields()"
+to get a field holding minimal values of the two fields.
+
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_MaxFields_1
+
+
+\anchor cpp_mcfielddouble_MergeFields
+<br><h2> Concatenating fields</h2>
+
+In this example we
+- create an 1D mesh and a field on it,
+- make a deep copy of the mesh and the field,
+- translate the mesh and the field,
+- use two variants of
+\ref ParaMEDMEM::MEDCouplingFieldDouble::MergeFields "MergeFields()"
+to create one field from the two by concatenating them and their meshes.
+
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_MergeFields_1
+The result field is twice "longer" than \b field1.
+
+
+
+\anchor cpp_mcfielddouble_substractInPlaceDM
+<br><h2> Subtracting field on different meshs </h2>
+
+We make two meshes in 1D space with no cells and 4 nodes. Nodes #0 and #2 are swapped
+in the two meshes.<br>
+And we make two fields on these meshes, so that fields values to equal to node
+coordinates of the underlying meshes.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_substractInPlaceDM_1
+We are going to subtract \b field2 from \b field1, though they are on
+different meshes.
+\ref ParaMEDMEM::MEDCouplingFieldDouble::substractInPlaceDM "substractInPlaceDM()"
+allows us doing this. We use a mesh comparison level \b levOfCheck = 10 that allows
+subtracting fields on meshes with different node arrays.<br>
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_substractInPlaceDM_2
+After applying
+\ref ParaMEDMEM::MEDCouplingFieldDouble::substractInPlaceDM "substractInPlaceDM()"
+the both fields lie on \b mesh2. As
+\ref ParaMEDMEM::MEDCouplingFieldDouble::substractInPlaceDM "substractInPlaceDM()"
+permutes values of \b field1 before value subtraction, and thus \b field1 becomes
+equal to \b feild2, hence their subtraction results in a zero field.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_substractInPlaceDM_3
+
+
+
+\anchor cpp_mcfielddouble_changeUnderlyingMesh
+<br><h2> Changing the underlying mesh </h2>
+
+We make two meshes in 1D space with no cells and 4 nodes. Nodes #0 and #2 are swapped
+in the two meshes.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_changeUnderlyingMesh_1
+We are going to use
+\ref ParaMEDMEM::MEDCouplingFieldDouble::changeUnderlyingMesh "changeUnderlyingMesh()"
+to set \b mesh2 instead of \b mesh1 as a support of a field. <br>
+We use
+\ref ParaMEDMEM::MEDCouplingMesh::fillFromAnalytic "fillFromAnalytic()"
+to make a field on nodes of \b mesh1, so that its values to equal to node coordinates.
+Then we use
+\ref ParaMEDMEM::MEDCouplingFieldDouble::changeUnderlyingMesh "changeUnderlyingMesh()"
+to change the underlying mesh of the \b field.
+(We use a mesh comparison level \b levOfCheck = 10 that allows substituting meshes with
+different node arrays.) As a result, we expect that values of the \b field are also
+permuted same as nodes of the two meshes, and thus its values become equal to the
+array \b coords2.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_changeUnderlyingMesh_2
+
+
+\anchor cpp_mcfielddouble_applyFunc_same_nb_comp
+<br><h2> Changing a field using a formular </h2>
+
+We create a 2D vector field with 2 tuples and we want to transform this
+field using a formular using
+\ref ParaMEDMEM::MEDCouplingFieldDouble::applyFunc(const char *func) "applyFunc()".
+The formular \b func is applied each atomic value of the \b field. We want to change
+the \b field as follows. (In \b func, we use the variable "v" to refer to an atomic field value).
+- Component #0 = component #0 (remains the same); hence "IVec * v" in \b func.
+- Component #1 = component #1 ^ 2; hence "JVec * v*v".
+
+In addition we want to add 10.0 to each component computed as described above, hence
+"10" in \b func.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_applyFunc_same_nb_comp_1
+Now we ascertain that the result field is as we expect.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_applyFunc_same_nb_comp_2
+
+
+
+\anchor cpp_mcfielddouble_applyFunc3
+<br><h2> Changing a field using a formular </h2>
+
+We create a 2D vector field with 2 values (vectors) and then we transform this
+field into a 3D vector field by applying a formular to values of the 2D field
+using
+\ref ParaMEDMEM::MEDCouplingFieldDouble::applyFunc3() "applyFunc3()".
+The formular \b func is applied to components of each vector of the \b field. We want
+the \b field to have 3 components computed as follows. (In \b func, we refer to the
+first component of a field value using the variable "a", and to the second component, using
+the variable "b", as we define it by \b varNamesVec).
+- Component #0 = the second vector component; hence "IVec * b" in \b func.
+- Component #1 = the first vector component; hence "JVec * a".
+- Component #2 = a vector magnitude; hence "KVec * sqrt( a*a + b*b )".
+
+In addition we want to add 10.0 to each component computed as described above, hence
+"10" in \b func.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_applyFunc3_1
+Now we ascertain that the result field is as we expect. We check the second vector of
+the \b field.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_applyFunc3_2
+
+
+
+\anchor cpp_mcfielddouble_applyFunc2
+<br><h2> Changing a field using a formular </h2>
+
+We create a 2D vector field with 2 values (vectors) and then we transform this
+field into a 3D vector field by applying a formular to values of the 2D field
+using
+\ref ParaMEDMEM::MEDCouplingFieldDouble::applyFunc2(int nbOfComp, const char *func) "applyFunc2()".
+Note that we set component info the \b array ("a" and "b" ) which will be used to refer to
+corresponding components within a function.
+The formular \b func is applied to components of each vector of the \b field. We want
+the \b field to have 3 components computed as follows. (In \b func, we refer to the
+first component of a field value using the variable "a", and to the second component, using
+the variable "b").
+- Component #0 = the second vector component; hence "IVec * b" in \b func.
+- Component #1 = the first vector component; hence "JVec * a".
+- Component #2 = a vector magnitude; hence "KVec * sqrt( a*a + b*b )".
+
+In addition we want to add 10.0 to each component computed as described above, hence
+"10" in \b func.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_applyFunc2_1
+Now we ascertain that the result field is as we expect. We check the second vector of
+the \b field.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_applyFunc2_2
+
+
+
+\anchor cpp_mcfielddouble_applyFunc
+<br><h2> Changing a field using a formular </h2>
+
+We create a 2D vector field with 2 values (vectors) and then we transform this
+field into a 3D vector field by applying a formular to values of the 2D field
+using
+\ref ParaMEDMEM::MEDCouplingFieldDouble::applyFunc(int nbOfComp, const char *func) "applyFunc()".
+The formular \b func is applied to components of each vector of the \b field. We want
+the \b field to have 3 components computed as follows. (In \b func, we refer to the
+first component of a field value using the variable "a", and to the second component, using
+the variable "b").
+- Component #0 = the second vector component; hence "IVec * b" in \b func.
+- Component #1 = the first vector component; hence "JVec * a".
+- Component #2 = a vector magnitude; hence "KVec * sqrt( a*a + b*b )".
+
+In addition we want to add 10.0 to each component computed as described above, hence
+"10" in \b func.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_applyFunc_1
+Now we ascertain that the result field is as we expect. We check the second vector of
+the \b field.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_applyFunc_2
+
+
+
+\anchor cpp_mcfielddouble_applyFunc_val
+<br><h2> Filling a field with a value</h2>
+
+We want to transform a 2D vector field to a 3D vector field so that all values to be
+equal to a certain value. First, we create the 2D mesh and the vector field on it.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_applyFunc_val_1
+Finally we use
+\ref ParaMEDMEM::MEDCouplingFieldDouble::applyFunc(int nbOfComp, double val) "applyFunc()"
+to change the number of components and all field values.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_applyFunc_val_2
+As a result, number of tuples in the field equals to the number of cells in the mesh,
+and number of components becomes equal to 3 as required.
+
+
+\anchor cpp_mcfielddouble_fillFromAnalytic3
+<br><h2> Filling a field using a formular </h2>
+
+First, we create a 2D Cartesian mesh constituted by 2 cells.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic3_1
+Now we create a field on cells and use
+\ref ParaMEDMEM::MEDCouplingFieldDouble::fillFromAnalytic2 "fillFromAnalytic2()"
+to fill it
+with values computed using a formular \b func. This formular is applied to coordinates of
+each point (barycenter) for which the field value is computed. We want the \b field
+to have 3 components computed as follows. (In \b func, we refer to the
+first component of a point using the variable "a", and to the second component, using
+the variable "b").
+- Component #0 = the second coordinate of the point; hence "IVec * b" in \b func.
+- Component #1 = the first coordinate of the point; hence "JVec * a".
+- Component #2 = distance between the point and SC origin (0.,0.); hence
+"KVec * sqrt( a*a + b*b )".
+
+In addition we want to add 10.0 to each component computed as described above, hence
+"10" in \b func.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic3_2
+Now we ascertain that the result field is as we expect. We check the second tuple of
+the \b field. We get barycenter of the cell #1 and checks that values of the second
+tuple are computed as we want.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic3_3
-First, we create a 2D mesh with 3 QUAD4 and 2 TRI3 cells.
-\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_
-\snippet MEDCouplingExamplesTest.py PySnippet_MEDCouplingUMesh_
-\snippet MEDCouplingExamplesTest.py Snippet_MEDCouplingUMesh_
+
+
+\anchor cpp_mcfielddouble_fillFromAnalytic2
+<br><h2> Filling a field using a formular </h2>
+
+First, we create a 2D Cartesian mesh constituted by 2 cells.
+Note that we set names to coordinates arrays ("a" and "b" ) which will be used to refer to
+corresponding coordinates within a function.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic2_1
+Now we create a field on cells and use
+\ref ParaMEDMEM::MEDCouplingFieldDouble::fillFromAnalytic2 "fillFromAnalytic2()"
+to fill it
+with values computed using a formular \b func. This formular is applied to coordinates of
+each point (barycenter) for which the field value is computed. We want the \b field
+to have 3 components computed as follows. (In \b func, we refer to the
+first component of a point using the variable "a", and to the second component, using
+the variable "b").
+- Component #0 = the second coordinate of the point; hence "IVec * b" in \b func.
+- Component #1 = the first coordinate of the point; hence "JVec * a".
+- Component #2 = distance between the point and SC origin (0.,0.); hence
+"KVec * sqrt( a*a + b*b )".
+
+In addition we want to add 10.0 to each component computed as described above, hence
+"10" in \b func.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic2_2
+Now we ascertain that the result field is as we expect. We check the second tuple of
+the \b field. We get barycenter of the cell #1 and checks that values of the second
+tuple are computed as we want.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic2_3
+
+
+\anchor cpp_mcfielddouble_fillFromAnalytic
+<br><h2> Filling a field using a formular </h2>
+
+First, we create a 2D Cartesian mesh constituted by 2 cells.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic_1
+Now we create a field on cells and use
+\ref ParaMEDMEM::MEDCouplingFieldDouble::fillFromAnalytic(int nbOfComp, const char *func) "fillFromAnalytic()"
+to fill it
+with values computed using a formular \b func. This formular is applied to coordinates of
+each point (barycenter) for which the field value is computed. We want the \b field to have
+ 3 components computed as follows. (In \b func, we refer to the
+first component of a point using the variable "a", and to the second component, using
+the variable "b").
+- Component #0 = the second coordinate of the point; hence "IVec * b" in \b func.
+- Component #1 = the first coordinate of the point; hence "JVec * a".
+- Component #2 = distance between the point and SC origin (0.,0.); hence
+"KVec * sqrt( a*a + b*b )".
+
+In addition we want to add 10.0 to each component computed as described above, hence
+"10" in \b func.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic_2
+Now we ascertain that the result field is as we expect. We check the second tuple of
+the \b field. We get barycenter of the cell #1 to check that values of the second
+tuple (#1) are computed as we want.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic_3
+
+
+\anchor cpp_mcfielddouble_getValueOn_time
+<br><h2> Getting a field value at some point at certain time</h2>
+
+First, we create a supporting structured mesh. We create a 2x2 Cartesian mesh
+constituted by 4 cells.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_getValueOn_time_1
+Then we create a scalar field on cells, whose values vary linearly in time.
+We set all field values at a start time to be equal 10.0 using
+\ref ParaMEDMEM::MEDCouplingFieldDouble::fillFromAnalytic "fillFromAnalytic()".
+And we set all field values at an end time to be equal 20.0 by doubling the start
+time array.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_getValueOn_time_2
+Now, we want to get a field value at a point [0,0] at a middle time between the start
+and end times. We expect the returned value to be equal to an average of 10. and 20.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_getValueOn_time_3
+
+
+\anchor cpp_mcfielddouble_getValueOnMulti
+<br><h2> Getting field values at some points</h2>
+
+First, we create a supporting structured mesh. We create a 2x2 Cartesian mesh
+constituted by 4 cells. Then we create a scalar field on cells using
+\ref ParaMEDMEM::MEDCouplingFieldDouble::fillFromAnalytic "fillFromAnalytic()".
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_getValueOnMulti_1
+Now, we want to retrieve all field values using
+\ref ParaMEDMEM::MEDCouplingFieldDouble::getValueOnMulti "getValueOnMulti()".
+The field values relate to cells, hence we will use cell barycenters as a parameter of
+\ref ParaMEDMEM::MEDCouplingFieldDouble::getValueOnMulti "getValueOnMulti()".
+We expect that the double array returned
+\ref ParaMEDMEM::MEDCouplingFieldDouble::getValueOnMulti "getValueOnMulti()"
+is equal to that stored by \b field.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_getValueOnMulti_2
+
+
+
+\anchor cpp_mcfielddouble_getValueOn
+<br><h2> Getting a field value at a point</h2>
+
+First, we create a supporting structured mesh. We create a 2x2 Cartesian mesh
+constituted by 4 cells. Then we create a scalar field on cells using
+\ref ParaMEDMEM::MEDCouplingFieldDouble::fillFromAnalytic "fillFromAnalytic()".
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_getValueOn_1
+Now, we want to retrieve all field values using
+\ref ParaMEDMEM::MEDCouplingFieldDouble::getValueOn "getValueOn()".
+The field values relate to cells, hence we will use cell barycenters to get a field
+value at each cell.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_getValueOn_2
+We collected all values returned by
+\ref ParaMEDMEM::MEDCouplingFieldDouble::getValueOn "getValueOn()" in an array, so
+that we can ascertain that the array of returned values is same as that stored by \b
+field.
+
+
+
+\anchor cpp_mcfielddouble_getValueOnPos
+<br><h2> Getting a value of field lying on a structured mesh</h2>
+
+First, we create a supporting structured mesh. We create a 2x2 Cartesian mesh
+constituted by 4 cells. Then we create a scalar field on cells using
+\ref ParaMEDMEM::MEDCouplingFieldDouble::fillFromAnalytic "fillFromAnalytic()".
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_getValueOnPos_1
+Now, we retrieve a field value relating to the cell #3 (this cell has a structured indexed
+(1,1)). For that we use
+\ref ParaMEDMEM::MEDCouplingFieldDouble::getValueOnPos "getValueOnPos()" where we
+pass the structured indexed of the cell: 1,1,-1 (the last index is meaningless as the
+mesh is 2D).
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_getValueOnPos_2
+After all we ascertain that the returned value corresponds to the formular used for
+the field creation. Namely that the value equals to the sum of components of
+barycenter of cell #3.
+
+
+
+\anchor cpp_mcfielddouble_renumberNodes
+<br><h2> Permuting a field on nodes</h2>
+
+First, we create a supporting 2D mesh constituted by 4 cells. We create a 2x2
+Cartesian mesh and then convert it to an unstructured one, since the Cartesian mesh
+is not suitable for
+\ref ParaMEDMEM::MEDCouplingFieldDouble::renumberNodes "renumberNodes()" as its
+ nature does not imply node renumbering.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_renumberNodes_1
+Then we create a field on nodes using
+\ref ParaMEDMEM::MEDCouplingFieldDouble::fillFromAnalytic "fillFromAnalytic()",
+such that its values to coincide with coordinates of field location points that are
+ nodes in our case (as our field is \ref ParaMEDMEM::ON_NODES "ON_NODES").
+At last we ascertain that field values are equal to node coordinates.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_renumberNodes_2
+Now, we are going to reverse order of nodes using
+\ref ParaMEDMEM::MEDCouplingFieldDouble::renumberNodes "renumberNodes()".
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_renumberNodes_3
+As a result, the underlying mesh of \b field is changed and its nodes are also
+ renumbered.
+And the field values are still equal to node coordinates of the renumbered \b mesh2.
+
+
+
+\anchor cpp_mcfielddouble_renumberCells
+<br><h2> Permuting a field on cells</h2>
+
+First, we create a supporting 2D mesh constituted by 4 cells. We create a 2x2
+Cartesian mesh and then convert it to an unstructured one, since the Cartesian mesh
+is not suitable for
+\ref ParaMEDMEM::MEDCouplingFieldDouble::renumberCells "renumberCells()" as its
+ nature does not imply cell renumbering.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_renumberCells_1
+Then we create a field on cells using
+\ref ParaMEDMEM::MEDCouplingFieldDouble::fillFromAnalytic "fillFromAnalytic()",
+such that its values to coincide with coordinates of field location points that are
+ cell barycenters in our case (as our field is \ref ParaMEDMEM::ON_CELLS "ON_CELLS").
+At last we ascertain that field values are equal to cell barycenters.
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_renumberCells_2
+Now, we are going to reverse order of cells using
+\ref ParaMEDMEM::MEDCouplingFieldDouble::renumberCells "renumberCells()".
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_renumberCells_3
+As a result, the underlying mesh of \b field is changed and its cells are also
+ renumbered.
+And the field values are still equal to cell barycenters of the renumbered \b mesh2.
+
+
+
+\anchor cpp_mcfielddouble_buildNewTimeReprFromThis
+<br><h2> Getting a field copy with different time discretization </h2>
+
+First, we create a supporting 2D mesh and a field on it got using
+\ref ParaMEDMEM::MEDCouplingFieldDouble::fillFromAnalytic "fillFromAnalytic()".
+\ref MEDCouplingTemporalDisc "Time discretization" of this field is
+\ref ParaMEDMEM::ONE_TIME "ONE_TIME".
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_buildNewTimeReprFromThis_1
+Now we use
+\ref ParaMEDMEM::MEDCouplingFieldDouble::buildNewTimeReprFromThis "buildNewTimeReprFromThis()"
+to get a copy of \b field1 whose time discretization is
+\ref ParaMEDMEM::NO_TIME "NO_TIME".
+\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_buildNewTimeReprFromThis_2
\anchor cpp_mcmesh_fillFromAnalytic3
Now each tuple of \b a2 includes components named "b","c","b","c","a","a". Thus
the result array \b a2 includes 30 elements (5 tuples per 6 components).
-\anchor cpp_mcfielddouble_subpart1
\anchor cpp_mcdataarrayint_keepselectedcomponents
-<!-- HTML footer for doxygen 1.8.3.1-->
-<!--BEGIN GENERATE_TREEVIEW-->
-<div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
- <ul>
- $navpath
- <li class="footer">
- Copyright © 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE<br>
- Copyright © 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS<br>
- </li>
- </ul>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+</head>
+<body>
+<div class="footer1">
+<!--hr style="width: 100%; height: 2px;"-->
+<div style="text-align: center;">
+Copyright © 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE<br>
+Copyright © 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS<br>
+</div>
</div>
-<!--END GENERATE_TREEVIEW-->
</body>
</html>
test_2D.sauve
allPillesTest.sauv
BDC-714.sauv
+ portico_3subs.sauv
)
IF(MED_ENABLE_GUI)
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
--- /dev/null
+ 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
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)
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)
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
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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).<br>
+ * For 1D cells, the returned field contains lengths.<br>
+ * For 2D cells, the returned field contains areas.<br>
+ * 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)
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)
}
/*!
- * 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<double>& refCoo,
const std::vector<double>& gsCoo, const std::vector<double>& wg) throw(INTERP_KERNEL::Exception)
}
/*!
- * 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<double>& refCoo,
const std::vector<double>& gsCoo, const std::vector<double>& wg) throw(INTERP_KERNEL::Exception)
}
/*!
- * 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()
{
}
/*!
- * 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 <em> 0 <= locId < getNbOfGaussLocalization() </em>.
+ * \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)
{
}
/*!
- * 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)
{
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<int> - 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<int> MEDCouplingField::getGaussLocalizationIdsOfOneType(INTERP_KERNEL::NormalizedCellType type) const throw(INTERP_KERNEL::Exception)
{
if(!_mesh)
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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 <em> 0 <= locId < getNbOfGaussLocalization() </em>.
+ * \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<int>& cellIds) const throw(INTERP_KERNEL::Exception)
{
}
/*!
- * 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 <em> 0 <= locId < getNbOfGaussLocalization() </em>.
+ * \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)
{
}
/*!
- * 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
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
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)
{
}
/*!
- * 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)
/*!
* Returns a time unit of \a this field.
- *
* \return a string describing units in which time is measured.
*/
const char *MEDCouplingFieldDouble::getTimeUnit() const
}
/*!
- * 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
{
}
/*!
- * 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
{
}
/*!
- * 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
{
}
/*!
- * 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."<br>
+ * \ref py_mcfielddouble_buildNewTimeReprFromThis "Here is a Python example."
+ * \sa clone()
*/
MEDCouplingFieldDouble *MEDCouplingFieldDouble::buildNewTimeReprFromThis(TypeOfTimeDiscretization td, bool deepCopy) const
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
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;
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;
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<const MEDCouplingFieldDouble *>(other);
}
/*!
- * 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".<br>
+ * \ref py_mcfielddouble_renumberCells "Here is a Python example".
*/
void MEDCouplingFieldDouble::renumberCells(const int *old2NewBg, bool check) throw(INTERP_KERNEL::Exception)
{
}
/*!
- * \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)
{
}
/*!
- * 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".<br>
+ * \ref py_mcfielddouble_renumberNodes "Here is a Python example".
*/
void MEDCouplingFieldDouble::renumberNodes(const int *old2NewBg, double eps) throw(INTERP_KERNEL::Exception)
{
}
/*!
- * \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)
{
}
/*!
- * 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)
{
}
/*!
- * 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.<br>
+ * 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().<br>
+ * 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().<br>
+ * 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".<br>
+ * \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)
/*!
* 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."<br>
* \ref py_mcfielddouble_subpart1 "Here a Python example."
* \sa ParaMEDMEM::MEDCouplingFieldDouble::buildSubPart(const DataArrayInt *) const, MEDCouplingFieldDouble::buildSubPartRange
*/
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();
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)
}
/*!
- * 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
{
}
/*!
- * 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
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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".<br>
+ * \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)
{
}
/*!
- * 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".<br>
+ * \ref py_mcfielddouble_getValueOn "Here is a Python example".
*/
void MEDCouplingFieldDouble::getValueOn(const double *spaceLoc, double *res) const throw(INTERP_KERNEL::Exception)
{
}
/*!
- * 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".<br>
+ * \ref py_mcfielddouble_getValueOnMulti "Here is a Python example".
*/
DataArrayDouble *MEDCouplingFieldDouble::getValueOnMulti(const double *spaceLoc, int nbOfPoints) const throw(INTERP_KERNEL::Exception)
{
}
/*!
- * 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".<br>
+ * \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)
{
}
/*!
- * 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 <em>(x)</em> 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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.<br>
+ * 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. <br>
+ * 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)!<br>
+ * 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.<br>
+ * 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".<br>
+ * \ref py_mcfielddouble_fillFromAnalytic "Here is a Python example".
*/
void MEDCouplingFieldDouble::fillFromAnalytic(int nbOfComp, const char *func) throw(INTERP_KERNEL::Exception)
{
}
/*!
- * 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.<br>
+ * 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.<br>
+ * 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()).<br>
+ * For more info on supported expressions that can be used in the function, see \ref
+ * MEDCouplingArrayApplyFuncExpr. <br>
+ * 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.<br>
+ * 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".<br>
+ * \ref py_mcfielddouble_fillFromAnalytic2 "Here is a Python example".
*/
void MEDCouplingFieldDouble::fillFromAnalytic2(int nbOfComp, const char *func) throw(INTERP_KERNEL::Exception)
{
}
/*!
- * 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.<br>
+ * 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.<br>
+ * 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.<br>
+ * 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.<br>
+ * 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".<br>
+ * \ref py_mcfielddouble_fillFromAnalytic3 "Here is a Python example".
*/
void MEDCouplingFieldDouble::fillFromAnalytic3(int nbOfComp, const std::vector<std::string>& varsOrder, const char *func) throw(INTERP_KERNEL::Exception)
{
}
/*!
- * Applyies the function specified by pointer 'func' on each tuples on all arrays contained in _time_discr.
- * If '*func' returns false during one evaluation an exception will be thrown.
+ * Modifies values of \a this field by applying a C function to each tuple of all
+ * data arrays.
+ * \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 \a func returns \c false.
+ *
+ * \ref cpp_mcfielddouble_applyFunc_c_func "Here is a C++ example".
*/
void MEDCouplingFieldDouble::applyFunc(int nbOfComp, FunctionToEvaluate func)
{
}
/*!
- * This method is a specialization of other overloaded methods. When 'nbOfComp' equals 1 this method is equivalent to
- * ParaMEDMEM::MEDCouplingFieldDouble::operator=.
+ * Fill \a this field with a given value.<br>
+ * 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".<br>
+ * \ref py_mcfielddouble_applyFunc_val "Here is a Python example".
*/
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. <br>
+ * 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)!<br>
+ * 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.<br>
+ * 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".<br>
+ * \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. <br>
+ * 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()).<br>
+ * 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.<br>
+ * 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".<br>
+ * \ref py_mcfielddouble_applyFunc2 "Here is a Python example".
*/
void MEDCouplingFieldDouble::applyFunc2(int nbOfComp, const char *func) throw(INTERP_KERNEL::Exception)
{
}
/*!
- * 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.<br>
+ * 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.<br>
+ * 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".<br>
+ * \ref py_mcfielddouble_applyFunc3 "Here is a Python example".
*/
void MEDCouplingFieldDouble::applyFunc3(int nbOfComp, const std::vector<std::string>& varsOrder, const char *func) throw(INTERP_KERNEL::Exception)
{
}
/*!
- * 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 exactly the same number of components after the call.
+ * Modifies values of \a this field by applying a function to each atomic value of all
+ * data arrays. The function computes a new single value basing on an old single value.
+ * For more info on supported expressions that can be used in the function, see \ref
+ * MEDCouplingArrayApplyFuncExpr. <br>
+ * The function can include **only one** arbitrary named variable
+ * (e.g. "x","y" or "va44") to refer to a field atomic value. <br>
+ * 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.<br>
+ * 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".<br>
+ * \ref py_mcfielddouble_applyFunc_same_nb_comp "Here is a Python example".
*/
void MEDCouplingFieldDouble::applyFunc(const char *func) throw(INTERP_KERNEL::Exception)
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
}
/*!
- * 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)
{
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();
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);
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))
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<DataArrayDouble *>& arrs) throw(INTERP_KERNEL::Exception)
{
_time_discr->setArrays(arrs,this);
}
/*!
- * This method tries to to change the mesh support of \a this following the parameter 'levOfCheck' and 'precOnMesh'.
- * Semantic of 'levOfCheck' is explained in MEDCouplingMesh::checkGeoEquivalWith method. This method is used to perform the job.
- * If this->_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".<br>
+ * \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)
{
}
/*!
- * 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.<br>
+ * 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.<br>
+ * This method requires that \a f and \a this are coherent (checkCoherency()) and that \a f
+ * and \a this are coherent for a merge.<br>
+ * "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".<br>
+ * \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)
{
}
/*!
- * 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)
{
}
/*!
- * 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.<br>
+ * 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)
{
}
/*!
- * 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.<br>
+ * \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)
{
}
/*!
- * 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.<br>
+ * \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)
{
}
/*!
- * 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.<br>
+ * \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)
{
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 <em>(t)</em> 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))
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))
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))
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))
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))
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))
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))
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))
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))
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<int>& compoIds) const throw(INTERP_KERNEL::Exception)
{
if(!((const MEDCouplingFieldDiscretization *)_type))
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<int>& 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".<br>
+ * \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))
}
/*!
- * 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".<br>
+ * \ref py_mcfielddouble_MergeFields "Here is a Python example".
*/
MEDCouplingFieldDouble *MEDCouplingFieldDouble::MergeFields(const std::vector<const MEDCouplingFieldDouble *>& a) throw(INTERP_KERNEL::Exception)
{
return ret.retn();
}
+/*!
+ * Creates a new MEDCouplingFieldDouble by concatenating components of two given fields.
+ * The number of components in the result field is a sum of the number of components of
+ * given fields. The number of tuples in the result field is same as that of each of given
+ * arrays.
+ * Number of tuples in the given fields must be the same.
+ * \param [in] f1 - a field to include in the result field.
+ * \param [in] f2 - another field to include in the result 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 the fields are not compatible for a meld (areCompatibleForMeld()).
+ * \throw If any of data arrays is not allocated.
+ * \throw If \a f1->getNumberOfTuples() != \a f2->getNumberOfTuples()
+ */
MEDCouplingFieldDouble *MEDCouplingFieldDouble::MeldFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception)
{
if(!f1->areCompatibleForMeld(f2))
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)
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)
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".<br>
+ * \ref py_mcfielddouble_MaxFields "Here is a Python example".
+ */
MEDCouplingFieldDouble *MEDCouplingFieldDouble::MaxFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception)
{
if(!f1)
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".<br>
+ * \ref py_mcfielddouble_MaxFields "Here is a Python example".
+ */
MEDCouplingFieldDouble *MEDCouplingFieldDouble::MinFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception)
{
if(!f1)
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))
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)
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))
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)
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))
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)
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))
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)
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))
}
/*!
- * 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".<br>
+ * \ref py_mcfielddouble_WriteVTK "Here is a Python example".
*/
void MEDCouplingFieldDouble::WriteVTK(const char *fileName, const std::vector<const MEDCouplingFieldDouble *>& fs) throw(INTERP_KERNEL::Exception)
{
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);
/*!
* 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.
* 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 ].
* 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.
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<T>& other);
bool isNull() const { return _pointer.isNull(); }
const T *getConstPointerLoc(std::size_t offset) const { return _pointer.getConstPointerLoc(offset); }
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<T> _pointer;
- DeallocType _dealloc;
+ Deallocator _dealloc;
+ void *_param_for_deallocator;
};
class DataArray : public RefCountObject, public TimeLabel
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<double>& accessToMemArray() { return _mem; }
+ MEDCOUPLING_EXPORT const MemArray<double>& accessToMemArray() const { return _mem; }
public:
MEDCOUPLING_EXPORT void getTinySerializationIntInformation(std::vector<int>& tinyInfo) const;
MEDCOUPLING_EXPORT void getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const;
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<int>& accessToMemArray() { return _mem; }
+ MEDCOUPLING_EXPORT const MemArray<int>& 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);
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<char>& accessToMemArray() { return _mem; }
+ MEDCOUPLING_EXPORT const MemArray<char>& accessToMemArray() const { return _mem; }
public:
//MEDCOUPLING_EXPORT void getTinySerializationIntInformation(std::vector<int>& tinyInfo) const;
//MEDCOUPLING_EXPORT void getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const;
}
template<class T>
- MemArray<T>::MemArray(const MemArray<T>& other):_nb_of_elem(0),_nb_of_elem_alloc(0),_ownership(false),_dealloc(CPP_DEALLOC)
+ MemArray<T>::MemArray(const MemArray<T>& other):_nb_of_elem(0),_nb_of_elem_alloc(0),_ownership(false),_dealloc(0),_param_for_deallocator(0)
{
if(!other._pointer.isNull())
{
else
_pointer.setExternal(array);
_ownership=ownership;
- _dealloc=type;
+ _dealloc=BuildFromType(type);
}
template<class T>
destroy();
_pointer.setInternal(const_cast<T *>(array));
_ownership=false;
- _dealloc=CPP_DEALLOC;
+ _dealloc=CPPDeallocator;
}
template<class T>
_nb_of_elem_alloc=nbOfElements;
_pointer.setInternal(new T[_nb_of_elem_alloc]);
_ownership=true;
- _dealloc=CPP_DEALLOC;
+ _dealloc=CPPDeallocator;
}
/*!
T *pointer=new T[newNbOfElements];
std::copy(_pointer.getConstPointer(),_pointer.getConstPointer()+std::min<std::size_t>(_nb_of_elem,newNbOfElements),pointer);
if(_ownership)
- destroyPointer(const_cast<T *>(_pointer.getConstPointer()),_dealloc);//Do not use getPointer because in case of _external
+ destroyPointer(const_cast<T *>(_pointer.getConstPointer()),_dealloc,_param_for_deallocator);//Do not use getPointer because in case of _external
_pointer.setInternal(pointer);
_nb_of_elem=std::min<std::size_t>(_nb_of_elem,newNbOfElements);
_nb_of_elem_alloc=newNbOfElements;
_ownership=true;
- _dealloc=CPP_DEALLOC;
+ _dealloc=CPPDeallocator;
+ _param_for_deallocator=0;
}
/*!
T *pointer=new T[newNbOfElements];
std::copy(_pointer.getConstPointer(),_pointer.getConstPointer()+std::min<std::size_t>(_nb_of_elem,newNbOfElements),pointer);
if(_ownership)
- destroyPointer(const_cast<T *>(_pointer.getConstPointer()),_dealloc);//Do not use getPointer because in case of _external
+ destroyPointer(const_cast<T *>(_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<class T>
- void MemArray<T>::destroyPointer(T *pt, DeallocType type)
+ void MemArray<T>::CPPDeallocator(void *pt, void *param)
+ {
+ delete [] reinterpret_cast<T*>(pt);
+ }
+
+ template<class T>
+ void MemArray<T>::CDeallocator(void *pt, void *param)
+ {
+ free(pt);
+ }
+
+ template<class T>
+ typename MemArray<T>::Deallocator MemArray<T>::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<class T>
+ void MemArray<T>::destroyPointer(T *pt, typename MemArray<T>::Deallocator dealloc, void *param)
+ {
+ if(dealloc)
+ dealloc(pt,param);
+ }
+
template<class T>
void MemArray<T>::destroy()
{
if(_ownership)
- destroyPointer(const_cast<T *>(_pointer.getConstPointer()),_dealloc);//Do not use getPointer because in case of _external
+ destroyPointer(const_cast<T *>(_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<class T>
* 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
//
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<int>(),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<int>(),maxId));
if(pt!=da->getConstPointer()+da->getNbOfElems())
throw INTERP_KERNEL::Exception("checkDeepEquivalWith : some cells in other are not in this !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellCor2=da->selectByTupleId2(getNumberOfCells(),da->getNbOfElems(),1);
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellCor2=da->selectByTupleId2(nbCells,da->getNbOfElems(),1);
nodeCor=nodeCor2->isIdentity()?0:nodeCor2.retn();
cellCor=cellCor2->isIdentity()?0:cellCor2.retn();
}
* 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.
* 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.
*
#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<DataArrayDouble> coordsArr = DataArrayDouble::New();
+ coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 );
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingCMesh> mesh1 = MEDCouplingCMesh::New();
+ mesh1->setCoords(coordsArr,coordsArr); // mesh becomes a 2D one
+
+ // 3 fields (lying on the same mesh!)
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> field1 =
+ mesh1->getMeasureField( true );
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> field2 =
+ mesh1->buildOrthogonalField();
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<const MEDCouplingFieldDouble *> 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<DataArrayDouble> valsArr1 = DataArrayDouble::New();
+ valsArr1->useExternalArrayWithRWAccess( vals1, 2,2 ); // 2 tuples per 2 components
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> field1 = MEDCouplingFieldDouble::New( ON_NODES );
+ field1->setArray( valsArr1 );
+ // field 2
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> valsArr2 = DataArrayDouble::New();
+ valsArr2->useExternalArrayWithRWAccess( vals2, 2,2 ); // 2 tuples per 2 components
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> field2 = MEDCouplingFieldDouble::New( ON_NODES );
+ field2->setArray( valsArr2 );
+ // max field
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> fieldMax = MEDCouplingFieldDouble::MaxFields( field1, field2 );
+ CPPUNIT_ASSERT( std::equal( valsMax, valsMax+4, fieldMax->getArray()->getConstPointer() )); // fieldMax == valsMax
+ // min field
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<DataArrayDouble> coordsArr = DataArrayDouble::New();
+ coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 );
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingCMesh> mesh1 = MEDCouplingCMesh::New();
+ mesh1->setCoords(coordsArr); // mesh becomes a 1D
+ // field1
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> field1 =
+ mesh1->fillFromAnalytic( ON_CELLS, 1, "x");
+
+ // mesh2 and field2
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<MEDCouplingFieldDouble> field3 =
+ MEDCouplingFieldDouble::MergeFields( field1, field2 );
+ std::vector<const MEDCouplingFieldDouble *> fields( 2 );
+ fields[0] = field1;
+ fields[1] = field2;
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<MEDCouplingUMesh> mesh1 = MEDCouplingUMesh::New();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> coordsArr = DataArrayDouble::New();
+ coordsArr->useExternalArrayWithRWAccess( coords1, 4, 1 );
+ mesh1->setCoords(coordsArr);
+ mesh1->setMeshDimension(0);
+ mesh1->allocateCells(0);
+ mesh1->finishInsertingCells();
+ // mesh 2
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> mesh2 =
+ (MEDCouplingUMesh*) mesh1->deepCpy();
+ mesh2->getCoords()->useExternalArrayWithRWAccess( coords2, 4, 1 );
+ //! [CppSnippet_MEDCouplingFieldDouble_substractInPlaceDM_1]
+ //! [CppSnippet_MEDCouplingFieldDouble_substractInPlaceDM_2]
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> field1 =
+ mesh1->fillFromAnalytic( ParaMEDMEM::ON_NODES,1,"x"); // field1 values == coords1
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<MEDCouplingUMesh> mesh1 = MEDCouplingUMesh::New();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> coordsArr = DataArrayDouble::New();
+ coordsArr->useExternalArrayWithRWAccess( coords1, 4, 1 );
+ mesh1->setCoords(coordsArr);
+ mesh1->setMeshDimension(0);
+ mesh1->allocateCells(0);
+ mesh1->finishInsertingCells();
+ // mesh 2
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> mesh2 =
+ (MEDCouplingUMesh*) mesh1->deepCpy();
+ mesh2->getCoords()->useExternalArrayWithRWAccess( coords2, 4, 1 );
+ //! [CppSnippet_MEDCouplingFieldDouble_changeUnderlyingMesh_1]
+ //! [CppSnippet_MEDCouplingFieldDouble_changeUnderlyingMesh_2]
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<DataArrayDouble> array = DataArrayDouble::New();
+ array->useExternalArrayWithRWAccess( v, 2, 2 ); // 2 tuples per 2 components
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<DataArrayDouble> array = DataArrayDouble::New();
+ array->useExternalArrayWithRWAccess( values, 2, 2 ); // 2 tuples per 2 components
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<std::string> 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<DataArrayDouble> 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<MEDCouplingFieldDouble> 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<DataArrayDouble> array = DataArrayDouble::New();
+ array->useExternalArrayWithRWAccess( values, 2, 2 ); // 2 tuples per 2 components
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<DataArrayDouble> coordsArr = DataArrayDouble::New();
+ coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 );
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingCMesh> mesh = MEDCouplingCMesh::New();
+ mesh->setCoords(coordsArr,coordsArr); // mesh becomes a 2D structured mesh
+ // field
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<DataArrayDouble> x = DataArrayDouble::New();
+ x->useExternalArrayWithRWAccess( coords, 3, 1 );
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> y = DataArrayDouble::New();
+ y->useExternalArrayWithRWAccess( coords, 2, 1 );
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingCMesh> mesh=MEDCouplingCMesh::New();
+ mesh->setCoords(x,y);
+ //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic3_1]
+ //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic3_2]
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<std::string> 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<DataArrayDouble> 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<DataArrayDouble> x = DataArrayDouble::New();
+ x->useExternalArrayWithRWAccess( coords, 3, 1 );
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> 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<MEDCouplingCMesh> mesh=MEDCouplingCMesh::New();
+ mesh->setCoords(x,y);
+ //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic2_1]
+ //! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic2_2]
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<DataArrayDouble> 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<DataArrayDouble> x = DataArrayDouble::New();
+ x->useExternalArrayWithRWAccess( coords, 3, 1 );
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> y = DataArrayDouble::New();
+ y->useExternalArrayWithRWAccess( coords, 2, 1 );
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingCMesh> 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<MEDCouplingFieldDouble> 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<DataArrayDouble> 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<DataArrayDouble> coordsArr = DataArrayDouble::New();
+ coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 );
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingCMesh> mesh = MEDCouplingCMesh::New();
+ mesh->setCoords(coordsArr,coordsArr); // mesh becomes a 2D structured mesh
+ // field
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<DataArrayDouble> coordsArr = DataArrayDouble::New();
+ coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 );
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingCMesh> mesh = MEDCouplingCMesh::New();
+ mesh->setCoords(coordsArr,coordsArr); // mesh becomes a 2D structured mesh
+ // field
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> field =
+ MEDCouplingFieldDouble::New( ParaMEDMEM::ON_CELLS );
+ field->setMesh( mesh );
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> 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<DataArrayDouble> coordsArr = DataArrayDouble::New();
+ coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 );
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingCMesh> mesh = MEDCouplingCMesh::New();
+ mesh->setCoords(coordsArr,coordsArr);
+ //! [CppSnippet_MEDCouplingFieldDouble_getValueOn_time_1]
+ //! [CppSnippet_MEDCouplingFieldDouble_getValueOn_time_2]
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> field =
+ MEDCouplingFieldDouble::New( ParaMEDMEM::ON_CELLS, ParaMEDMEM::LINEAR_TIME );
+ field->setMesh( mesh );
+ field->fillFromAnalytic( 1,"10"); // all values == 10.
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> 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<DataArrayDouble> coordsArr = DataArrayDouble::New();
+ coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 );
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingCMesh> mesh = MEDCouplingCMesh::New();
+ mesh->setCoords(coordsArr,coordsArr);
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<DataArrayDouble> bc = mesh->getBarycenterAndOwner();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> 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<DataArrayDouble> coordsArr = DataArrayDouble::New();
+ coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 );
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingCMesh> mesh = MEDCouplingCMesh::New();
+ mesh->setCoords(coordsArr,coordsArr);
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<DataArrayDouble> bc = mesh->getBarycenterAndOwner();
+ std::vector<double> 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<DataArrayDouble> coordsArr = DataArrayDouble::New();
+ coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 );
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingCMesh> mesh = MEDCouplingCMesh::New();
+ mesh->setCoords(coordsArr,coordsArr);
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<DataArrayDouble> 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<DataArrayDouble> coordsArr = DataArrayDouble::New();
+ coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 );
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingCMesh> cmesh = MEDCouplingCMesh::New();
+ cmesh->setCoords(coordsArr,coordsArr);
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> mesh = cmesh->buildUnstructured();
+ //! [CppSnippet_MEDCouplingFieldDouble_renumberNodes_1]
+ //! [CppSnippet_MEDCouplingFieldDouble_renumberNodes_2]
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<DataArrayDouble> coordsArr = DataArrayDouble::New();
+ coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 );
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingCMesh> cmesh = MEDCouplingCMesh::New();
+ cmesh->setCoords(coordsArr,coordsArr);
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> mesh = cmesh->buildUnstructured();
+ //! [CppSnippet_MEDCouplingFieldDouble_renumberCells_1]
+ //! [CppSnippet_MEDCouplingFieldDouble_renumberCells_2]
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> field =
+ mesh->fillFromAnalytic( ParaMEDMEM::ON_CELLS,2,"IVec*x+JVec*y");
+ const DataArrayDouble* values = field->getArray();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> 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<DataArrayDouble> coordsArr = DataArrayDouble::New();
+ coordsArr->useExternalArrayWithRWAccess( coords, 3, 1 );
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingCMesh> mesh = MEDCouplingCMesh::New();
+ mesh->setCoords(coordsArr,coordsArr);
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<MEDCouplingFieldDouble> 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]
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<DataArrayDouble> bc =
mesh->getBarycenterAndOwner(); // func is applied to barycenters of cells
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]
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<DataArrayDouble> bc =
mesh->getBarycenterAndOwner(); // func is applied to barycenters of cells
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]
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<DataArrayDouble> bc =
mesh->getBarycenterAndOwner(); // func is applied to barycenters of cells
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]
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();
CppSnippetFieldDoubleBuild2();
CppSnippetFieldDoubleBuild3();
CppSnippetFieldDoubleBuild4();
+
return 0;
}
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)
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)
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}
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)
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
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}
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)
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)
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
$result=convertDataArrayChar($1,$owner);
}
-#ifdef WITH_NUMPY2
+#ifdef WITH_NUMPY
%init %{ import_array(); %}
#endif
};
}
+%inline
+{
+ bool MEDCouplingHasNumpyBindings()
+ {
+#ifdef WITH_NUMPY
+ return true;
+#else
+ return false;
+#endif
+ }
+}
+
%include "MEDCouplingMemArray.i"
namespace ParaMEDMEM
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):
return ret.retn();
}
}
+#ifdef WITH_NUMPY
+ else if(PyArray_Check(elt0))
+ {//DataArrayDouble.New(numpyArray)
+ return BuildNewInstance<DataArrayDouble,double>(elt0,NPY_DOUBLE,&PyCallBackDataArrayDouble_RefType,"FLOAT64");
+ }
+#endif
else
throw INTERP_KERNEL::Exception(msg);
}
return convertDblArrToPyList(vals,self->getNbOfElems());
}
+#ifdef WITH_NUMPY
+ PyObject *toNumPyArray() throw(INTERP_KERNEL::Exception) // not const. It is not a bug !
+ {
+ return ToNumPyArray<DataArrayDouble,double>(self,NPY_DOUBLE,"DataArrayDouble");
+ }
+#endif
+
PyObject *isEqualIfNotWhy(const DataArrayDouble& other, double prec) const throw(INTERP_KERNEL::Exception)
{
std::string ret1;
return ret.retn();
}
}
+#ifdef WITH_NUMPY
+ else if(PyArray_Check(elt0))
+ {//DataArrayInt.New(numpyArray)
+ return BuildNewInstance<DataArrayInt,int>(elt0,NPY_INT,&PyCallBackDataArrayInt_RefType,"INT32");
+ }
+#endif
else
throw INTERP_KERNEL::Exception(msg);
}
return convertIntArrToPyList(vals,self->getNbOfElems());
}
+#ifdef WITH_NUMPY
+ PyObject *toNumPyArray() throw(INTERP_KERNEL::Exception) // not const. It is not a bug !
+ {
+ return ToNumPyArray<DataArrayInt,int>(self,NPY_INT,"DataArrayInt");
+ }
+#endif
+
PyObject *isEqualIfNotWhy(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception)
{
std::string ret1;
--- /dev/null
+# -*- 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()
#include "InterpKernelAutoPtr.hxx"
-#ifdef WITH_NUMPY2
+#ifdef WITH_NUMPY
#include <numpy/arrayobject.h>
+
+void numarrdeal(void *pt, void *wron)
+{
+ void **wronc=(void **)wron;
+ PyObject *weakRefOnOwner=reinterpret_cast<PyObject *>(wronc[0]);
+ PyObject *obj=PyWeakref_GetObject(weakRefOnOwner);
+ if(obj!=Py_None)
+ {
+ Py_XINCREF(obj);
+ PyArrayObject *objC=reinterpret_cast<PyArrayObject *>(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<class MCData>
+struct PyCallBackDataArraySt {
+ PyObject_HEAD
+ MCData *_pt_mc;
+};
+
+typedef struct PyCallBackDataArraySt<ParaMEDMEM::DataArrayInt> PyCallBackDataArrayInt;
+typedef struct PyCallBackDataArraySt<ParaMEDMEM::DataArrayDouble> 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<int>& 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<double>& 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<class MCData>
+void numarrdeal2(void *pt, void *obj)
+{
+ typedef struct PyCallBackDataArraySt<MCData> PyCallBackDataArray;
+ void **obj1=(void **)obj;
+ PyCallBackDataArray *cbdaic=reinterpret_cast<PyCallBackDataArray *>(obj1[0]);
+ PyObject *weakRefOnOwner=reinterpret_cast<PyObject *>(obj1[1]);
+ cbdaic->_pt_mc=0;
+ Py_XDECREF(weakRefOnOwner);
+ Py_XDECREF(cbdaic);
+ delete [] obj1;
+}
+
+template<class MCData, class T>
+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<stride)
+ throw INTERP_KERNEL::Exception("Input numpy array has item size < stride !");
+ if(stride!=sizeof(T))
+ {
+ std::ostringstream oss; oss << "Input numpy array has not stride set to " << sizeof(T) << " !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ npy_intp sz=PyArray_DIM(elt0,0);
+ const char *data=PyArray_BYTES(elt0);
+ typename ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<MCData> ret=MCData::New();
+ if(PyArray_ISBEHAVED(elt0))//aligned and writeable and in machine byte-order
+ {
+ PyArrayObject *elt0C=reinterpret_cast<PyArrayObject *>(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<PyArrayObject *>(base);
+ eltOwning=(PyArray_FLAGS(baseC) & NPY_OWNDATA)?baseC:eltOwning;
+ baseC->flags&=mask;
+ base=baseC->base;
+ if(base) deepestObj=base;
+ }
+ else
+ break;
+ }
+ typename ParaMEDMEM::MemArray<T>& mma=ret->accessToMemArray();
+ if(eltOwning==NULL)
+ {
+ PyCallBackDataArraySt<MCData> *cb=PyObject_GC_New(PyCallBackDataArraySt<MCData>,pytype);
+ cb->_pt_mc=ret;
+ ret->useArray(reinterpret_cast<const T *>(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<MCData>);
+ //"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<const T *>(data),true,ParaMEDMEM::C_DEALLOC,sz,1);
+ PyObject *ref=PyWeakref_NewRef(reinterpret_cast<PyObject *>(eltOwning),NULL);
+ void **objs=new void *[2]; objs[0]=ref; objs[1]=(void*) ParaMEDMEM::MemArray<T>::CDeallocator;
+ mma.setParameterForDeallocator(objs);
+ mma.setSpecificDeallocator(numarrdeal);
+ }
+ }
+ else if(PyArray_ISBEHAVED_RO(elt0))
+ ret->useArray(reinterpret_cast<const T *>(data),false,ParaMEDMEM::CPP_DEALLOC,sz,1);
+ return ret.retn();
+}
+
+template<class MCData, class T>
+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<T>& 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<T *>(bg));
+ if(mem.isDeallocatorCalled())
+ {
+ if(mem.getDeallocator()!=ParaMEDMEM::MemArray<T>::CDeallocator)
+ {
+ int mask=NPY_OWNDATA; mask=~mask;
+ (reinterpret_cast<PyArrayObject *>(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<T>::CDeallocator;
+ mem.setParameterForDeallocator(objs);
+ mem.setSpecificDeallocator(numarrdeal);
+ return ret;
+ }
+ }
+ return ret;
+}
+
#endif
static PyObject *convertMesh(ParaMEDMEM::MEDCouplingMesh *mesh, int owner) throw(INTERP_KERNEL::Exception)
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<size;i++)
PyList_SetItem(ret,i,PyInt_FromLong(ptr[i]));
return ret;
-#else
- npy_intp dim = (npy_intp) size;
- int *tmp=new int[size];
- std::copy(ptr,ptr+size,tmp);
- return PyArray_SimpleNewFromData(1,&dim,NPY_INT,const_cast<int *>(tmp));
-#endif
}
static PyObject *convertIntArrToPyList2(const std::vector<int>& v) throw(INTERP_KERNEL::Exception)
{
-#ifndef WITH_NUMPY2
int size=v.size();
PyObject *ret=PyList_New(size);
for(int i=0;i<size;i++)
PyList_SetItem(ret,i,PyInt_FromLong(v[i]));
return ret;
-#else
- npy_intp dim = (npy_intp) v.size();
- int *tmp=new int[v.size()];
- std::copy(v.begin(),v.end(),tmp);
- return PyArray_SimpleNewFromData(1,&dim,NPY_INT,tmp);
-#endif
}
static PyObject *convertIntArrToPyList3(const std::set<int>& v) throw(INTERP_KERNEL::Exception)
}
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
}
}
}
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
}
}
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
{
std::string oname(name);
std::map<std::string, std::vector<std::string> >::const_iterator it=_groups.find(oname);
- std::vector<std::string> grps=getGroupsNames();
if(it==_groups.end())
{
+ std::vector<std::string> grps=getGroupsNames();
std::ostringstream oss; oss << "No such groupname \"" << name << "\" !\nAvailable groups are :";
std::copy(grps.begin(),grps.end(),std::ostream_iterator<std::string>(oss," "));
throw INTERP_KERNEL::Exception(oss.str().c_str());
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
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)
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)
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<MEDCouplingUMesh> 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<DataArrayDouble> 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<MEDFileUMesh> m= MEDFileUMesh::New();
m->setMeshAtLevel(0,mesh2d);
// Create families and groups
- DataArrayInt *fam = DataArrayInt::New();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> fam = DataArrayInt::New();
fam->alloc(2,1);
int elemsFams[2] = {-2,-3};
std::copy(elemsFams,elemsFams+2,fam->getPointer());
// write to SAUV
const char* sauvFile = "mesh_with_void_family.sauv";
- MEDFileData* medData = MEDFileData::New();
- MEDFileMeshes* medMeshes = MEDFileMeshes::New();
- SauvWriter* sw=SauvWriter::New();
+ MEDCouplingAutoRefCountObjectPtr<MEDFileData> medData = MEDFileData::New();
+ MEDCouplingAutoRefCountObjectPtr<MEDFileMeshes> medMeshes = MEDFileMeshes::New();
+ MEDCouplingAutoRefCountObjectPtr<SauvWriter> sw=SauvWriter::New();
medMeshes->setMeshAtPos(0, m);
medData->setMeshes(medMeshes);
sw->setMEDFileDS(medData);
// read SAUV and check groups
MEDCouplingAutoRefCountObjectPtr<SauvReader> sr=SauvReader::New(sauvFile);
MEDCouplingAutoRefCountObjectPtr<MEDFileData> d2=sr->loadInMEDFileDS();
- MEDFileUMesh * m2 = static_cast<MEDFileUMesh*>( d2->getMeshes()->getMeshAtPos(0) );
- std::vector<std::string > 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<MEDFileUMesh*>( d2->getMeshes()->getMeshAtPos(0) );
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> grp1 = m2->getGroup(0, "Group1");
CPPUNIT_ASSERT_EQUAL(1,(int)grp1->getNumberOfCells());
- MEDCouplingUMesh * grp2 = m2->getGroup(0, "Group2");
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> grp2 = m2->getGroup(0, "Group2");
CPPUNIT_ASSERT_EQUAL(1,(int)grp2->getNumberOfCells());
- MEDCouplingUMesh * grptot = m2->getGroup(0, "Grouptot");
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> 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<SauvReader> sr=SauvReader::New(sauvFile.c_str());
+ MEDCouplingAutoRefCountObjectPtr<MEDFileData> d2=sr->loadInMEDFileDS();
+ // check mesh
+ MEDFileUMesh* m2 = static_cast<MEDFileUMesh*>(d2->getMeshes()->getMeshAtPos(0));
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> mesh1d = m2->getMeshAtLevel(0);
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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<MEDFileFieldMultiTS> 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<int,int> > timesteps = field->getIterations();
+
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> 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()
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();
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)
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})
