\snippet MEDCouplingExamplesTest.py PySnippetDataArrayBuild1_0
-The easiest way to build the \ref ParaMEDMEM::DataArrayDouble "DataArrayDouble instance" called \c arrayDouble simply call :
+The easiest way to build the \ref MEDCoupling::DataArrayDouble "DataArrayDouble instance" called \c arrayDouble simply call :
\snippet MEDCouplingExamplesTest.py PySnippetDataArrayBuild1_1bis
\snippet MEDCouplingExamplesTest.py PySnippetDataArrayBuild1_2
-The easiest way to build the \ref ParaMEDMEM::DataArrayInt "DataArrayInt instance" called \c arrayInt simply call :
+The easiest way to build the \ref MEDCoupling::DataArrayInt "DataArrayInt instance" called \c arrayInt simply call :
\snippet MEDCouplingExamplesTest.py PySnippetDataArrayBuild1_3bis
In this example we will create arrays with 12 tuples constituted each
of 3 components. These arrays will be created using different ways.\n
-The following code is only based using \ref ParaMEDMEM::DataArrayDouble "DataArrayDouble"
-but the use of \ref ParaMEDMEM::DataArrayInt "DataArrayInt" is strictly equivalent.
+The following code is only based using \ref MEDCoupling::DataArrayDouble "DataArrayDouble"
+but the use of \ref MEDCoupling::DataArrayInt "DataArrayInt" is strictly equivalent.
\snippet MEDCouplingExamplesTest.cxx CppSnippetDataArrayBuild1_0
\anchor MEDCouplingArrayBasicsCopyDeepAssign
<h3>Assignation by deep copy of DataArray</h3>
-We start by building a instance of ParaMEDMEM::DataArrayDouble allocated or not. Here, instance is not allocated, only built empty.
+We start by building a instance of MEDCoupling::DataArrayDouble allocated or not. Here, instance is not allocated, only built empty.
\snippet MEDCouplingExamplesTest.cxx CppSnippetDataArrayBuild1_11
\snippet MEDCouplingExamplesTest.cxx CppSnippetDataArrayBuild1_12
-Then \c coordsArrCpy is a deep copy of \c coordsArr except that the instance of ParaMEDMEM::DataArrayDouble is those specified.
+Then \c coordsArrCpy is a deep copy of \c coordsArr except that the instance of MEDCoupling::DataArrayDouble is those specified.
But the behaviour is the same than those seen for \ref MEDCouplingArrayBasicsCopyDeepTestEqual "deep copy".
\snippet MEDCouplingExamplesTest.cxx CppSnippetDataArrayBuild1_13
\subsubsection cpp_mcdataarrayint_buildpermutationarr Building a permutation array
Here we create two arrays containing same values but in different order and then we use
-\ref ParaMEDMEM::DataArrayInt::buildPermutationArr "DataArrayInt::buildPermutationArr()" to get
+\ref MEDCoupling::DataArrayInt::buildPermutationArr "DataArrayInt::buildPermutationArr()" to get
an array showing in what places the values of \b b array are located in \b a array.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_DataArrayInt_buildPermutationArr_1
The result array \b c contains [1,0,4,2,3].
Here we re-fill \b da with zeros and copy \b dv into a component of \b da.
Note that the last parameter \b strictCompoCompare should be \c False
-in this case, else \ref ParaMEDMEM::DataArrayDouble::setPartOfValues1()
+in this case, else \ref MEDCoupling::DataArrayDouble::setPartOfValues1()
throws an exception because \b da has 2 components but only one target
component is specified.
\snippet MEDCouplingExamplesTest.py Snippet_DataArrayDouble_setPartOfValues1_3
Tuple #2 : 0 7 0 7
Tuple #3 : 0 0 0 0
</pre>
-\note \ref ParaMEDMEM::DataArrayDouble::setPartOfValuesSimple2() can't
+\note \ref MEDCoupling::DataArrayDouble::setPartOfValuesSimple2() can't
be explicitly called in Python.
Tuple #2 : 0 7 0 7
Tuple #3 : 0 0 0 0
</pre>
-\note \ref ParaMEDMEM::DataArrayDouble::setPartOfValuesSimple3() can't
+\note \ref MEDCoupling::DataArrayDouble::setPartOfValuesSimple3() can't
be explicitly called in Python.
Tuple #2 : 7 0 8 9 10 11 12
Tuple #3 : 7 0 8 9 10 11 12
</pre>
-\note \ref ParaMEDMEM::DataArrayDouble::setPartOfValues2() can't
+\note \ref MEDCoupling::DataArrayDouble::setPartOfValues2() can't
be explicitly called in Python.
Tuple #2 : 7 0 8 9 10 11 12
Tuple #3 : 0 0 0 0 0 0 0
</pre>
-\note \ref ParaMEDMEM::DataArrayDouble::setPartOfValues3() can't
+\note \ref MEDCoupling::DataArrayDouble::setPartOfValues3() can't
be explicitly called in Python.
Here we re-fill \b da with zeros and copy \b dv into a component of \b da.
Note that the last parameter \b strictCompoCompare should be \c False
-in this case, else \ref ParaMEDMEM::DataArrayInt::setPartOfValues1()
+in this case, else \ref MEDCoupling::DataArrayInt::setPartOfValues1()
throws an exception because \b da has 2 components but only one target
component is specified.
\snippet MEDCouplingExamplesTest.py Snippet_DataArrayInt_setPartOfValues1_3
Tuple #2 : 0 7 0 7
Tuple #3 : 0 0 0 0
</pre>
-\note \ref ParaMEDMEM::DataArrayInt::setPartOfValuesSimple2() can't
+\note \ref MEDCoupling::DataArrayInt::setPartOfValuesSimple2() can't
be explicitly called in Python.
Tuple #2 : 0 7 0 7
Tuple #3 : 0 0 0 0
</pre>
-\note \ref ParaMEDMEM::DataArrayInt::setPartOfValuesSimple3() can't
+\note \ref MEDCoupling::DataArrayInt::setPartOfValuesSimple3() can't
be explicitly called in Python.
Tuple #2 : 7 0 8 9 10 11 12
Tuple #3 : 7 0 8 9 10 11 12
</pre>
-\note \ref ParaMEDMEM::DataArrayInt::setPartOfValues2() can't
+\note \ref MEDCoupling::DataArrayInt::setPartOfValues2() can't
be explicitly called in Python.
Tuple #2 : 7 0 8 9 10 11 12
Tuple #3 : 0 0 0 0 0 0 0
</pre>
-\note \ref ParaMEDMEM::DataArrayInt::setPartOfValues3() can't
+\note \ref MEDCoupling::DataArrayInt::setPartOfValues3() can't
be explicitly called in Python.
In this example we create two data arrays including \b same number of
tuples and then we concatenate them using \ref
-ParaMEDMEM::DataArrayDouble::meldWith "meldWith()".
+MEDCoupling::DataArrayDouble::meldWith "meldWith()".
\snippet MEDCouplingExamplesTest.cxx CppSnippet_DataArrayDouble_Meld1_1
Now the array \b da1 includes 7 tuples (as before) of 3 components
each. Its components are: "c0da1","c1da1","c0da2".
In this example we create two data arrays including \b same number of
tuples and then we concatenate them using \ref
-ParaMEDMEM::DataArrayInt::meldWith "meldWith()".
+MEDCoupling::DataArrayInt::meldWith "meldWith()".
\snippet MEDCouplingExamplesTest.cxx CppSnippet_DataArrayInt_Meld1_1
Now the array \b da1 includes 7 tuples (as before) of 3 components
each. Its components are: "c0da1","c1da1","c0da2".
the result array \b a2 includes 30 elements (5 tuples per 6 components).
Note that
-\ref ParaMEDMEM::DataArrayInt::keepSelectedComponents() "DataArrayInt::keepSelectedComponents()"
+\ref MEDCoupling::DataArrayInt::keepSelectedComponents() "DataArrayInt::keepSelectedComponents()"
is called, providing the same result, by the following python code:
\snippet MEDCouplingExamplesTest.py SnippeDataArrayIntKeepSelectedComponents1_3
In this example we
- create two fields with two tuples per two components,
- use
-\ref ParaMEDMEM::MEDCouplingFieldDouble::MaxFields "MaxFields()"
+\ref MEDCoupling::MEDCouplingFieldDouble::MaxFields "MaxFields()"
to get a field holding maximal values of the two fields.
- use
-\ref ParaMEDMEM::MEDCouplingFieldDouble::MinFields "MinFields()"
+\ref MEDCoupling::MEDCouplingFieldDouble::MinFields "MinFields()"
to get a field holding minimal values of the two fields.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_MaxFields_1
- 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()"
+\ref MEDCoupling::MEDCouplingFieldDouble::MergeFields "MergeFields()"
to create one field from the two by concatenating them and their meshes.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_MergeFields_1
\subsubsection cpp_mcfielddouble_buildNewTimeReprFromThis Getting a field copy with different time discretization
First, we create a supporting 2D mesh and a field on it got using
-\ref ParaMEDMEM::MEDCouplingFieldDouble::fillFromAnalytic "fillFromAnalytic()".
+\ref MEDCoupling::MEDCouplingFieldDouble::fillFromAnalytic "fillFromAnalytic()".
\ref MEDCouplingTemporalDisc "Time discretization" of this field is
-\ref ParaMEDMEM::ONE_TIME "ONE_TIME".
+\ref MEDCoupling::ONE_TIME "ONE_TIME".
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_buildNewTimeReprFromThis_1
Now we use
-\ref ParaMEDMEM::MEDCouplingFieldDouble::buildNewTimeReprFromThis "buildNewTimeReprFromThis()"
+\ref MEDCoupling::MEDCouplingFieldDouble::buildNewTimeReprFromThis "buildNewTimeReprFromThis()"
to get a copy of \b field1 whose time discretization is
-\ref ParaMEDMEM::NO_TIME "NO_TIME".
+\ref MEDCoupling::NO_TIME "NO_TIME".
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_buildNewTimeReprFromThis_2
First, we create a 2D Cartesian mesh constituted by 2 cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingMesh_fillFromAnalytic3_1
Now we use
-\ref ParaMEDMEM::MEDCouplingMesh::fillFromAnalytic3 "fillFromAnalytic3()"
-to get a \ref ParaMEDMEM::MEDCouplingFieldDouble "MEDCouplingFieldDouble" on cells filled
+\ref MEDCoupling::MEDCouplingMesh::fillFromAnalytic3 "fillFromAnalytic3()"
+to get a \ref MEDCoupling::MEDCouplingFieldDouble "MEDCouplingFieldDouble" on cells filled
with values computed using an expression \b func. This expression is applied to coordinates of
each point (barycenter) for which the field value is computed. We want to get the
field on cells, with 3 components computed as follows. (In \b func, we refer to the
corresponding coordinates within a function.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingMesh_fillFromAnalytic2_1
Now we use
-\ref ParaMEDMEM::MEDCouplingMesh::fillFromAnalytic2 "fillFromAnalytic2()"
-to get a \ref ParaMEDMEM::MEDCouplingFieldDouble "MEDCouplingFieldDouble" on cells filled
+\ref MEDCoupling::MEDCouplingMesh::fillFromAnalytic2 "fillFromAnalytic2()"
+to get a \ref MEDCoupling::MEDCouplingFieldDouble "MEDCouplingFieldDouble" on cells filled
with values computed using an expression \b func. This expression is applied to coordinates of
each point (barycenter) for which the field value is computed. We want to get the
field on cells, with 3 components computed as follows. (In \b func, we refer to the
First, we create a 2D Cartesian mesh constituted by 2 cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingMesh_fillFromAnalytic_1
Now we use
-\ref ParaMEDMEM::MEDCouplingMesh::fillFromAnalytic "fillFromAnalytic()"
-to get a \ref ParaMEDMEM::MEDCouplingFieldDouble "MEDCouplingFieldDouble" on cells filled
+\ref MEDCoupling::MEDCouplingMesh::fillFromAnalytic "fillFromAnalytic()"
+to get a \ref MEDCoupling::MEDCouplingFieldDouble "MEDCouplingFieldDouble" on cells filled
with values computed using an expression \b func. This expression is applied to coordinates of
each point (barycenter) for which the field value is computed. We want to get the
field on cells, with 3 components computed as follows. (In \b func, we refer to the
Now let's create a subfield on cells \b f2 from \b f1.
\snippet MEDCouplingExamplesTest.cxx CppSnippetFieldDoubleBuildSubPart1_2
-\b f1 is a field on cells, \ref ParaMEDMEM::MEDCouplingFieldDouble::buildSubPart "buildSubPart" method performs an extraction on cells too.
+\b f1 is a field on cells, \ref MEDCoupling::MEDCouplingFieldDouble::buildSubPart "buildSubPart" method performs an extraction on cells too.
So the array \b part1 lists ids on cells.
Now let's create a subfield on nodes \b f2 from \b f1.
\snippet MEDCouplingExamplesTest.cxx CppSnippetFieldDoubleBuildSubPart1_4
-\b f1 is a field on nodes, but \ref ParaMEDMEM::MEDCouplingFieldDouble::buildSubPart "buildSubPart" method performs an extraction on \b cells.
+\b f1 is a field on nodes, but \ref MEDCoupling::MEDCouplingFieldDouble::buildSubPart "buildSubPart" method performs an extraction on \b cells.
-After the call of \ref ParaMEDMEM::MEDCouplingFieldDouble::buildSubPart "buildSubPart" on node field \b f1, \b f1 will be reduced on a
+After the call of \ref MEDCoupling::MEDCouplingFieldDouble::buildSubPart "buildSubPart" on node field \b f1, \b f1 will be reduced on a
submesh of \b mesh1 containing cells whose ids are in \b part2. So here the number of cells of \b f2 is 2 and the number of nodes is 4.
\n
-So contrary to fields on cells, it is normal for fields on nodes that number of tuples of the returned field of \ref ParaMEDMEM::MEDCouplingFieldDouble::buildSubPart "buildSubPart"
+So contrary to fields on cells, it is normal for fields on nodes that number of tuples of the returned field of \ref MEDCoupling::MEDCouplingFieldDouble::buildSubPart "buildSubPart"
method does not match the size of the input array (here \b part2).
\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()"
+\ref MEDCoupling::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()"
+\ref MEDCoupling::MEDCouplingFieldDouble::substractInPlaceDM "substractInPlaceDM()"
the both fields lie on \b mesh2. As
-\ref ParaMEDMEM::MEDCouplingFieldDouble::substractInPlaceDM "substractInPlaceDM()"
+\ref MEDCoupling::MEDCouplingFieldDouble::substractInPlaceDM "substractInPlaceDM()"
permutes values of \b field1 before value subtraction, and thus \b field1 becomes
equal to \b field2, hence their subtraction results in a zero field.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_substractInPlaceDM_3
in the two meshes.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_changeUnderlyingMesh_1
We are going to use
-\ref ParaMEDMEM::MEDCouplingFieldDouble::changeUnderlyingMesh "changeUnderlyingMesh()"
+\ref MEDCoupling::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()"
+\ref MEDCoupling::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()"
+\ref MEDCoupling::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
We create a 2D vector field with 2 tuples and we want to transform this
field using an expression using
-\ref ParaMEDMEM::MEDCouplingFieldDouble::applyFunc(int, const std::string&) "applyFunc()".
+\ref MEDCoupling::MEDCouplingFieldDouble::applyFunc(int, const std::string&) "applyFunc()".
The expression \b func is applied to 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.
We create a 2D vector field with 2 values (vectors) and then we transform this
field into a 3D vector field by applying an expression to values of the 2D field
using
-\ref ParaMEDMEM::MEDCouplingFieldDouble::applyFunc3() "applyFunc3()".
+\ref MEDCoupling::MEDCouplingFieldDouble::applyFunc3() "applyFunc3()".
The expression \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
We create a 2D vector field with 2 values (vectors) and then we transform this
field into a 3D vector field by applying an expression to values of the 2D field
using
-\ref ParaMEDMEM::MEDCouplingFieldDouble::applyFunc2(int nbOfComp, const std::string&) "applyFunc2()".
+\ref MEDCoupling::MEDCouplingFieldDouble::applyFunc2(int nbOfComp, const std::string&) "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 expression \b func is applied to components of each vector of the \b field. We want
We create a 2D vector field with 2 values (vectors) and then we transform this
field into a 3D vector field by applying an expression to values of the 2D field
using
-\ref ParaMEDMEM::MEDCouplingFieldDouble::applyFunc(int nbOfComp, const std::string& func) "applyFunc()".
+\ref MEDCoupling::MEDCouplingFieldDouble::applyFunc(int nbOfComp, const std::string& func) "applyFunc()".
The expression \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
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()"
+\ref MEDCoupling::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,
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()"
+\ref MEDCoupling::MEDCouplingFieldDouble::fillFromAnalytic2 "fillFromAnalytic2()"
to fill it
with values computed using an expression \b func. This expression is applied to coordinates of
each point (barycenter) for which the field value is computed. We want the \b field
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()"
+\ref MEDCoupling::MEDCouplingFieldDouble::fillFromAnalytic2 "fillFromAnalytic2()"
to fill it
with values computed using an expression \b func. This expression is applied to coordinates of
each point (barycenter) for which the field value is computed. We want the \b field
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 std::string& func) "fillFromAnalytic()"
+\ref MEDCoupling::MEDCouplingFieldDouble::fillFromAnalytic(int nbOfComp, const std::string& func) "fillFromAnalytic()"
to fill it
with values computed using an expression \b func. This expression is applied to coordinates of
each point (barycenter) for which the field value is computed. We want the \b field to have
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
+\ref MEDCoupling::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()",
+\ref MEDCoupling::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").
+ nodes in our case (as our field is \ref MEDCoupling::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()".
+\ref MEDCoupling::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.
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
+\ref MEDCoupling::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()",
+\ref MEDCoupling::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").
+ cell barycenters in our case (as our field is \ref MEDCoupling::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()".
+\ref MEDCoupling::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.
coordinates of a 2D point.
\snippet MEDCouplingExamplesTest.cxx Snippet_MEDCouplingFieldDouble_fillFromAnalytic_c_func_0
Then we create the 2D mesh and the field on it, and finally we use
-\ref ParaMEDMEM::MEDCouplingFieldDouble::fillFromAnalytic(int nbOfComp, FunctionToEvaluate func) "fillFromAnalytic()"
+\ref MEDCoupling::MEDCouplingFieldDouble::fillFromAnalytic(int nbOfComp, FunctionToEvaluate func) "fillFromAnalytic()"
to fill the field with values each composed of 3 components.
\snippet MEDCouplingExamplesTest.cxx Snippet_MEDCouplingFieldDouble_fillFromAnalytic_c_func_1
As a result, number of tuples in the field equals to the number of cells in the mesh,
Then we create the 2D mesh and the vector field on it.
\snippet MEDCouplingExamplesTest.cxx Snippet_MEDCouplingFieldDouble_applyFunc_c_func_1
Finally we use
-\ref ParaMEDMEM::MEDCouplingFieldDouble::applyFunc(int nbOfComp, FunctionToEvaluate func) "applyFunc()"
+\ref MEDCoupling::MEDCouplingFieldDouble::applyFunc(int nbOfComp, FunctionToEvaluate func) "applyFunc()"
to change the field values.
\snippet MEDCouplingExamplesTest.cxx Snippet_MEDCouplingFieldDouble_applyFunc_c_func_2
As a result, number of tuples in the field equals to the number of cells in the mesh,
\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()".
+\ref MEDCoupling::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
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()".
+\ref MEDCoupling::MEDCouplingFieldDouble::fillFromAnalytic "fillFromAnalytic()".
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_getValueOnMulti_1
Now, we want to retrieve all field values using
-\ref ParaMEDMEM::MEDCouplingFieldDouble::getValueOnMulti "getValueOnMulti()".
+\ref MEDCoupling::MEDCouplingFieldDouble::getValueOnMulti "getValueOnMulti()".
The field values relate to cells, hence we will use cell barycenters as a parameter of
-\ref ParaMEDMEM::MEDCouplingFieldDouble::getValueOnMulti "getValueOnMulti()".
+\ref MEDCoupling::MEDCouplingFieldDouble::getValueOnMulti "getValueOnMulti()".
We expect that the double array returned
-\ref ParaMEDMEM::MEDCouplingFieldDouble::getValueOnMulti "getValueOnMulti()"
+\ref MEDCoupling::MEDCouplingFieldDouble::getValueOnMulti "getValueOnMulti()"
is equal to that stored by \b field.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_getValueOnMulti_2
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()".
+\ref MEDCoupling::MEDCouplingFieldDouble::fillFromAnalytic "fillFromAnalytic()".
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_getValueOn_1
Now, we want to retrieve all field values using
-\ref ParaMEDMEM::MEDCouplingFieldDouble::getValueOn "getValueOn()".
+\ref MEDCoupling::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
+\ref MEDCoupling::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.
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()".
+\ref MEDCoupling::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
+\ref MEDCoupling::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
Firstly retrieve basic data in full interlace mode for coordinates, and nodal connectivity cell per cell.
\snippet MEDCouplingExamplesTest.cxx CppSnippetUMeshStdBuild1_1
-Then create ParaMEDMEM::MEDCouplingUMesh instance giving its mesh dimension (2 here) and a name.
+Then create MEDCoupling::MEDCouplingUMesh instance giving its mesh dimension (2 here) and a name.
\snippet MEDCouplingExamplesTest.cxx CppSnippetUMeshStdBuild1_2
Gives an upper bound of the number of cells to be inserted into the unstructured mesh.
-\n Then enter nodal connectivity of all cells, cell per cell using ParaMEDMEM::MEDCouplingUMesh::insertNextCell method.
-\n When the nodal connectivity cell per cell has been finished, call ParaMEDMEM::MEDCouplingUMesh::finishInsertingCells method in order to restore \b mesh instance.
+\n Then enter nodal connectivity of all cells, cell per cell using MEDCoupling::MEDCouplingUMesh::insertNextCell method.
+\n When the nodal connectivity cell per cell has been finished, call MEDCoupling::MEDCouplingUMesh::finishInsertingCells method in order to restore \b mesh instance.
\snippet MEDCouplingExamplesTest.cxx CppSnippetUMeshStdBuild1_3
Firstly retrieve basic data in full interlace mode for coordinates, and nodal connectivity cell per cell, cell type \b included (3 for INTERP_KERNEL::NORM_TRI3 and 4 for INTERP_KERNEL::QUAD4).
\snippet MEDCouplingExamplesTest.cxx CppSnippetUMeshAdvBuild1_1
-Then create ParaMEDMEM::MEDCouplingUMesh instance giving its mesh dimension (2 here) and a name.
+Then create MEDCoupling::MEDCouplingUMesh instance giving its mesh dimension (2 here) and a name.
\snippet MEDCouplingExamplesTest.cxx CppSnippetUMeshAdvBuild1_2
We are going to build a 2D cartesian mesh, constituted from 9 nodes along X axis, and 7 nodes along Y axis.
-Firstly retrieve for each direction the discretization and build a \ref ParaMEDMEM::DataArrayDouble "DataArrayDouble instance" on the corresponding direction.
+Firstly retrieve for each direction the discretization and build a \ref MEDCoupling::DataArrayDouble "DataArrayDouble instance" on the corresponding direction.
\snippet MEDCouplingExamplesTest.cxx CppSnippetCMeshStdBuild1_1
-Then create ParaMEDMEM::MEDCouplingCMesh instance giving the 2 instances of \ref ParaMEDMEM::DataArrayDouble "DataArrayDouble" obtained above.
+Then create MEDCoupling::MEDCouplingCMesh instance giving the 2 instances of \ref MEDCoupling::DataArrayDouble "DataArrayDouble" obtained above.
There are 2 techniques to get it.
First, we create a 2D mesh with 3 QUAD4 and 2 TRI3 cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_buildBoundaryMesh_1
Now we use
-\ref ParaMEDMEM::MEDCouplingUMesh::buildBoundaryMesh "buildBoundaryMesh()" to get a mesh
+\ref MEDCoupling::MEDCouplingUMesh::buildBoundaryMesh "buildBoundaryMesh()" to get a mesh
of lower dimension bounding \b mesh.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_buildBoundaryMesh_2
Depending on the value of a parameter,
-\ref ParaMEDMEM::MEDCouplingUMesh::buildBoundaryMesh "buildBoundaryMesh()"
+\ref MEDCoupling::MEDCouplingUMesh::buildBoundaryMesh "buildBoundaryMesh()"
creates the mesh sharing the node coordinates array with \b mesh or not.
First, we create a 2D mesh with 3 QUAD4 and 2 TRI3 cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_buildFacePartOfMySelfNode_1
In the following code we retrieve nodes of the cell #0 an then we call
-\ref ParaMEDMEM::MEDCouplingUMesh::buildFacePartOfMySelfNode "buildFacePartOfMySelfNode()"
+\ref MEDCoupling::MEDCouplingUMesh::buildFacePartOfMySelfNode "buildFacePartOfMySelfNode()"
twice with these nodes and with varying last parameter \b allNodes as input.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_buildFacePartOfMySelfNode_2
<br>If the last parameter is \c true
-\ref ParaMEDMEM::MEDCouplingUMesh::buildFacePartOfMySelfNode "buildFacePartOfMySelfNode()" looks
+\ref MEDCoupling::MEDCouplingUMesh::buildFacePartOfMySelfNode "buildFacePartOfMySelfNode()" looks
for segements whose all nodes are given to it, hence it finds segments bounding the cell #0 only.
<br>If the last parameter is \c false
-\ref ParaMEDMEM::MEDCouplingUMesh::buildFacePartOfMySelfNode "buildFacePartOfMySelfNode()" looks
+\ref MEDCoupling::MEDCouplingUMesh::buildFacePartOfMySelfNode "buildFacePartOfMySelfNode()" looks
for any segment whose nodes are given to it, hence it adds more segments to \b mesh2.
First, we create a 2D mesh with 3 QUAD4 and 2 TRI3 cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_buildPartOfMySelfNode_1
In the following code we retrieve nodes of the cell #0 an then we call
-\ref ParaMEDMEM::MEDCouplingUMesh::buildPartOfMySelfNode "buildPartOfMySelfNode()"
+\ref MEDCoupling::MEDCouplingUMesh::buildPartOfMySelfNode "buildPartOfMySelfNode()"
twice with these nodes and with varying last parameter \b allNodes as input.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_buildPartOfMySelfNode_2
<br>If the last parameter is \c true
-\ref ParaMEDMEM::MEDCouplingUMesh::buildPartOfMySelfNode "buildPartOfMySelfNode()" looks
+\ref MEDCoupling::MEDCouplingUMesh::buildPartOfMySelfNode "buildPartOfMySelfNode()" looks
for cells whose all nodes are given to it, hence it finds the cell #0 only.
<br>If the last parameter is \c false
-\ref ParaMEDMEM::MEDCouplingUMesh::buildPartOfMySelfNode "buildPartOfMySelfNode()" looks
+\ref MEDCoupling::MEDCouplingUMesh::buildPartOfMySelfNode "buildPartOfMySelfNode()" looks
for any cell whose nodes are given to it, hence it finds all cells of \b mesh because all
cells share the node #4.
First, we create a 2D mesh with 3 QUAD4 and 2 TRI3 cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_buildPartOfMySelf_1
Now we use
-\ref ParaMEDMEM::MEDCouplingUMesh::buildPartOfMySelf "buildPartOfMySelf()" to get a mesh
+\ref MEDCoupling::MEDCouplingUMesh::buildPartOfMySelf "buildPartOfMySelf()" to get a mesh
containing only two cells of \b mesh.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_buildPartOfMySelf_2
First, we create a mesh with 2 incorrectly oriented "extruded" volumes.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_findAndCorrectBadOriented3DExtrudedCells_1
Now we check that
-\ref ParaMEDMEM::MEDCouplingUMesh::findAndCorrectBadOriented3DExtrudedCells "findAndCorrectBadOriented3DExtrudedCells()"
+\ref MEDCoupling::MEDCouplingUMesh::findAndCorrectBadOriented3DExtrudedCells "findAndCorrectBadOriented3DExtrudedCells()"
finds and fixes the reversed cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_findAndCorrectBadOriented3DExtrudedCells_2
two "extruded" polyhedra and then convert them to correctly defined polyhedra.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_arePolyhedronsNotCorrectlyOriented_1
Now we check that
-\ref ParaMEDMEM::MEDCouplingUMesh::arePolyhedronsNotCorrectlyOriented "arePolyhedronsNotCorrectlyOriented()"
+\ref MEDCoupling::MEDCouplingUMesh::arePolyhedronsNotCorrectlyOriented "arePolyhedronsNotCorrectlyOriented()"
finds one reversed cell. After that we fix it using
-\ref ParaMEDMEM::MEDCouplingUMesh::orientCorrectlyPolyhedrons "orientCorrectlyPolyhedrons()" and
+\ref MEDCoupling::MEDCouplingUMesh::orientCorrectlyPolyhedrons "orientCorrectlyPolyhedrons()" and
re-check the orientation of polyhedra.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_arePolyhedronsNotCorrectlyOriented_2
reversed comparing with others.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_are2DCellsNotCorrectlyOriented_1
Now we check that
-\ref ParaMEDMEM::MEDCouplingUMesh::are2DCellsNotCorrectlyOriented "are2DCellsNotCorrectlyOriented()"
+\ref MEDCoupling::MEDCouplingUMesh::are2DCellsNotCorrectlyOriented "are2DCellsNotCorrectlyOriented()"
finds one reversed face. After that we fix the incorrectly oriented cell using
-\ref ParaMEDMEM::MEDCouplingUMesh::orientCorrectly2DCells "orientCorrectly2DCells()" and
+\ref MEDCoupling::MEDCouplingUMesh::orientCorrectly2DCells "orientCorrectly2DCells()" and
re-check the orientation of cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_are2DCellsNotCorrectlyOriented_2
First, we create a 2D mesh with 1 QUAD4 cell and with undefined coordinates of nodes.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_renumberNodesInConn_1
Now we use
-\ref ParaMEDMEM::MEDCouplingUMesh::renumberNodesInConn "renumberNodesInConn()"
+\ref MEDCoupling::MEDCouplingUMesh::renumberNodesInConn "renumberNodesInConn()"
to get the following nodal connectivity of a sole cell: 0,1,2,3.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_renumberNodesInConn_2
\b old2newIds array defines how node ids are changed:
First, we create a 2D mesh with 4 nodes and no cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_renumberNodes_1
Next, we use
-\ref ParaMEDMEM::MEDCouplingUMesh::renumberNodes "renumberNodes()"
+\ref MEDCoupling::MEDCouplingUMesh::renumberNodes "renumberNodes()"
to permute nodes so that
- old node #0 becomes #2,
- old node #1 remains #1,
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_renumberNodes_2
Next we compare behavior of
-\ref ParaMEDMEM::MEDCouplingUMesh::renumberNodes "renumberNodes()" and that of
-\ref ParaMEDMEM::MEDCouplingUMesh::renumberNodes2 "renumberNodes2()" which, in contrast to
-\ref ParaMEDMEM::MEDCouplingUMesh::renumberNodes "renumberNodes()",
+\ref MEDCoupling::MEDCouplingUMesh::renumberNodes "renumberNodes()" and that of
+\ref MEDCoupling::MEDCouplingUMesh::renumberNodes2 "renumberNodes2()" which, in contrast to
+\ref MEDCoupling::MEDCouplingUMesh::renumberNodes "renumberNodes()",
moves merged nodes to their barycenter.<br>
We set #2 as new id of old node #3 and expect that
-\ref ParaMEDMEM::MEDCouplingUMesh::renumberNodes2 "renumberNodes2()" moves old nodes #0
+\ref MEDCoupling::MEDCouplingUMesh::renumberNodes2 "renumberNodes2()" moves old nodes #0
and #3 to their barycenter (-0.3,0.0) which becomes position of node #2.<br>
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_renumberNodes_3
of which 2 nodes fully coincide (#3 and #4) and 3 nodes are equal with precision 0.003.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_mergeNodes_1
Now we merge node duplicates using
-\ref ParaMEDMEM::MEDCouplingUMesh::mergeNodes "mergeNodes()" and check values it returns.
+\ref MEDCoupling::MEDCouplingUMesh::mergeNodes "mergeNodes()" and check values it returns.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_mergeNodes_2
Contents of \b arr shows ids of old nodes after the merging. The nodes considered equal
one to the other have the same id in \b arr.
Next we compare behavior of
-\ref ParaMEDMEM::MEDCouplingUMesh::mergeNodes "mergeNodes()" and that of
-\ref ParaMEDMEM::MEDCouplingUMesh::mergeNodes2 "mergeNodes2()" which, in contrast to
-\ref ParaMEDMEM::MEDCouplingUMesh::mergeNodes "mergeNodes()",
+\ref MEDCoupling::MEDCouplingUMesh::mergeNodes "mergeNodes()" and that of
+\ref MEDCoupling::MEDCouplingUMesh::mergeNodes2 "mergeNodes2()" which, in contrast to
+\ref MEDCoupling::MEDCouplingUMesh::mergeNodes "mergeNodes()",
moves merged nodes to their barycenter.<br> We expect that
-\ref ParaMEDMEM::MEDCouplingUMesh::mergeNodes2 "mergeNodes2()" moves old nodes #0, #2
+\ref MEDCoupling::MEDCouplingUMesh::mergeNodes2 "mergeNodes2()" moves old nodes #0, #2
and #5 to their barycenter equal to position of node #2.<br>
First we check that
-\ref ParaMEDMEM::MEDCouplingUMesh::mergeNodes "mergeNodes()" does not move nodes
+\ref MEDCoupling::MEDCouplingUMesh::mergeNodes "mergeNodes()" does not move nodes
coincident with the node #2 to the position of node #2, and then we check that
-\ref ParaMEDMEM::MEDCouplingUMesh::mergeNodes "mergeNodes2()" does move.
+\ref MEDCoupling::MEDCouplingUMesh::mergeNodes "mergeNodes2()" does move.
(We check only the second (Y) component of node coordinates since the first component of
these nodes is exactly same.)
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_mergeNodes_3
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_zipConnectivityTraducer_1
Now we use
-\ref ParaMEDMEM::MEDCouplingUMesh::zipConnectivityTraducer "zipConnectivityTraducer()"
+\ref MEDCoupling::MEDCouplingUMesh::zipConnectivityTraducer "zipConnectivityTraducer()"
to remove duplicate cells. Then we check that two cells, having exactly same nodal
connectivity with other cells, have been removed.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_zipConnectivityTraducer_2
The cell #3 equals to the cell #0 (== \b arr[3] ).<br>
The cell #4 has no equal cell. This is because the cell comparison technique specified
when we called
-\ref ParaMEDMEM::MEDCouplingUMesh::zipConnectivityTraducer "zipConnectivityTraducer()"
+\ref MEDCoupling::MEDCouplingUMesh::zipConnectivityTraducer "zipConnectivityTraducer()"
was 0 ("exact"), if we had used the technique 2 ("nodal"), \b arr[4] would be 0.
First, we create a 2D mesh with 3 QUAD4 and 2 TRI3 cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_zipCoordsTraducer_1
Now we create \b mesh2 including all nodes but only two cells of \b mesh, and we use \ref
-ParaMEDMEM::MEDCouplingUMesh::zipCoordsTraducer "zipCoordsTraducer()" to remove unused
+MEDCoupling::MEDCouplingUMesh::zipCoordsTraducer "zipCoordsTraducer()" to remove unused
nodes from \b mesh2.
-\ref ParaMEDMEM::MEDCouplingUMesh::zipCoordsTraducer "zipCoordsTraducer()" returns an array
+\ref MEDCoupling::MEDCouplingUMesh::zipCoordsTraducer "zipCoordsTraducer()" returns an array
with -1 for unused nodes and new ids for used ones.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_zipCoordsTraducer_2
First, we create a 2D mesh with 3 QUAD4 and 2 TRI3 cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getNodeIdsInUse_1
Now we create \b mesh2 including all nodes but only two cells of \b mesh, and we use \ref
-ParaMEDMEM::MEDCouplingUMesh::getNodeIdsInUse "getNodeIdsInUse()" to get nodes of \b mesh2
+MEDCoupling::MEDCouplingUMesh::getNodeIdsInUse "getNodeIdsInUse()" to get nodes of \b mesh2
used in its two cells.
-\ref ParaMEDMEM::MEDCouplingUMesh::getNodeIdsInUse "getNodeIdsInUse()" returns an array
+\ref MEDCoupling::MEDCouplingUMesh::getNodeIdsInUse "getNodeIdsInUse()" returns an array
with -1 for unused nodes and new ids for used ones.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getNodeIdsInUse_2
Now we use \b newNbOfNodes returned by
-\ref ParaMEDMEM::MEDCouplingUMesh::getNodeIdsInUse "getNodeIdsInUse()" to convert \b arr
+\ref MEDCoupling::MEDCouplingUMesh::getNodeIdsInUse "getNodeIdsInUse()" to convert \b arr
to "New to Old" mode.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getNodeIdsInUse_3
\subsubsection cpp_mccmesh_getCoordsAt Getting node coordinates along an axis
We create an 1D Cartesian mesh and retrieves node coordinates using
-\ref ParaMEDMEM::MEDCouplingCMesh::getCoordsAt "getCoordsAt()".
+\ref MEDCoupling::MEDCouplingCMesh::getCoordsAt "getCoordsAt()".
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingCMesh_getCoordsAt_1
\subsubsection cpp_mcpointset_getcoordinatesofnode Getting coordinates of a node
-The following code creates a 2D \ref ParaMEDMEM::MEDCouplingUMesh
+The following code creates a 2D \ref MEDCoupling::MEDCouplingUMesh
"MEDCouplingUMesh" with 3 nodes and no cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingPointSet_getCoordinatesOfNode_1
Here we get coordinates of the second node and check its two coordinates.
share the same node coordinates array.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_areCellsIncludedIn_2
Now we ascertain that
-- \ref ParaMEDMEM::MEDCouplingUMesh::areCellsIncludedIn "areCellsIncludedIn()"
+- \ref MEDCoupling::MEDCouplingUMesh::areCellsIncludedIn "areCellsIncludedIn()"
detects that all cells of \b mesh2 are present in \b mesh1,
- the correspondence array \b corr2to1, which gives cell ids of \b mesh2 within
\b mesh1, is equal to the array \b cells2 which selected cells from \b mesh1 for creation
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_areCellsIncludedIn_3
Now we apply
-\ref ParaMEDMEM::MEDCouplingUMesh::areCellsIncludedIn "areCellsIncludedIn()"
+\ref MEDCoupling::MEDCouplingUMesh::areCellsIncludedIn "areCellsIncludedIn()"
in a reverse direction and ascertain that it returns \c false.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_areCellsIncludedIn_4
The contents of the correspondence
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_checkDeepEquivalWith_1
Then we check that
-- \ref ParaMEDMEM::MEDCouplingUMesh::checkDeepEquivalWith "checkDeepEquivalWith()"
+- \ref MEDCoupling::MEDCouplingUMesh::checkDeepEquivalWith "checkDeepEquivalWith()"
considers the meshes equal (i.e. it does not throw any exception) if it is called with a cell
comparison policy \b cellCompPol == 1
- mapping from \b mesh1 to \b mesh2 for both nodes and cells is as expected.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_checkDeepEquivalWith_2
Next we ascertain that
-\ref ParaMEDMEM::MEDCouplingUMesh::checkDeepEquivalOnSameNodesWith "checkDeepEquivalOnSameNodesWith()"
+\ref MEDCoupling::MEDCouplingUMesh::checkDeepEquivalOnSameNodesWith "checkDeepEquivalOnSameNodesWith()"
consider \b mesh1 and \b mesh2 different as they do not share the same nodal connectivity
array. <br>
After that we make the meshes share the node coordinates array and insert new
triangles based on the same nodes but in different order. This is to ascertain that
-\ref ParaMEDMEM::MEDCouplingUMesh::checkDeepEquivalOnSameNodesWith "checkDeepEquivalOnSameNodesWith()"
+\ref MEDCoupling::MEDCouplingUMesh::checkDeepEquivalOnSameNodesWith "checkDeepEquivalOnSameNodesWith()"
called with the weakest cell comparison policy considers the meshes equal.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_checkDeepEquivalWith_3
First, we create a 2D mesh with 3 QUAD4 and 2 TRI3 cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getPartMeasureField_1
Now we use
-\ref ParaMEDMEM::MEDCouplingUMesh::getPartBarycenterAndOwner "getPartBarycenterAndOwner()" to get
+\ref MEDCoupling::MEDCouplingUMesh::getPartBarycenterAndOwner "getPartBarycenterAndOwner()" to get
barycenters of all but the first cell.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getPartMeasureField_3
The returned array contains 4 tuples per 2 components.
First, we create a 2D mesh with 3 QUAD4 and 2 TRI3 cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getCellsContainingPoints_1
Then we use
-\ref ParaMEDMEM::MEDCouplingUMesh::getCellsContainingPoints "getCellsContainingPoints()" to
+\ref MEDCoupling::MEDCouplingUMesh::getCellsContainingPoints "getCellsContainingPoints()" to
get cells in contact with tree points. Two of them are in contact with some cells and one is not.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getCellsContainingPoints_2
The contents of the result arrays \b cells ([4, 0, 1]) and \b cellsIndex ([0, 0, 1, 3])
First, we create a 2D mesh with 3 QUAD4 and 2 TRI3 cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getCellsContainingPoint_1
Then we use
-\ref ParaMEDMEM::MEDCouplingUMesh::getCellsContainingPoint "getCellsContainingPoint()" to
+\ref MEDCoupling::MEDCouplingUMesh::getCellsContainingPoint "getCellsContainingPoint()" to
get cells in contact with a small ball (point with precision) located near the node #4 and
shifted from this node by its radius \b eps.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getCellsContainingPoint_2
reversed.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_buildPartOrthogonalField_1
Now we use
-\ref ParaMEDMEM::MEDCouplingUMesh::buildPartOrthogonalField "buildPartOrthogonalField()" to get
+\ref MEDCoupling::MEDCouplingUMesh::buildPartOrthogonalField "buildPartOrthogonalField()" to get
normal vectors to the cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_buildPartOrthogonalField_2
reversed.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getPartMeasureField_1
Now we use
-\ref ParaMEDMEM::MEDCouplingUMesh::getPartMeasureField "getPartMeasureField()" to get
+\ref MEDCoupling::MEDCouplingUMesh::getPartMeasureField "getPartMeasureField()" to get
volumes of all but the first cell. If we call
-\ref ParaMEDMEM::MEDCouplingUMesh::getPartMeasureField "getPartMeasureField()" with \b
+\ref MEDCoupling::MEDCouplingUMesh::getPartMeasureField "getPartMeasureField()" with \b
isAbs == \c true, the area of the cell #1 is returned positive, else, negative that
reflects its inverse orientation.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getPartMeasureField_2
First, we create a 2D mesh with 1 TRI3 cell. Bounding box of this cell is [0.,0., 1.,1].
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getCellsInBoundingBox_1
Now we check how
-\ref ParaMEDMEM::MEDCouplingUMesh::getCellsInBoundingBox "getCellsInBoundingBox()"
+\ref MEDCoupling::MEDCouplingUMesh::getCellsInBoundingBox "getCellsInBoundingBox()"
searches for cells using the bounding box. We use a bounding box touching the bounding box
of the sole cell at one point (1.,1.).
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getCellsInBoundingBox_2
-If \ref ParaMEDMEM::MEDCouplingUMesh::getCellsInBoundingBox "getCellsInBoundingBox()" is
+If \ref MEDCoupling::MEDCouplingUMesh::getCellsInBoundingBox "getCellsInBoundingBox()" is
called with parameter \b eps == 0.0, the cell is not found because the two bounding boxes
(one of the cell and the one passed as parameter) do not overlap. <br>
-If \ref ParaMEDMEM::MEDCouplingUMesh::getCellsInBoundingBox "getCellsInBoundingBox()" is
+If \ref MEDCoupling::MEDCouplingUMesh::getCellsInBoundingBox "getCellsInBoundingBox()" is
called with parameter \b eps == 0.1, the cell is found because \b eps is used to increase
the bounding box of the cell and thus the two bounding boxes intersect each other. <br>
First, we create a 2D mesh with 3 QUAD4 and 2 TRI3 cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_findBoundaryNodes_1
Now we use
-\ref ParaMEDMEM::MEDCouplingUMesh::findBoundaryNodes "findBoundaryNodes()" to get ids
+\ref MEDCoupling::MEDCouplingUMesh::findBoundaryNodes "findBoundaryNodes()" to get ids
of boundary nodes.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_findBoundaryNodes_2
-\ref ParaMEDMEM::MEDCouplingUMesh::findBoundaryNodes "findBoundaryNodes()" returns all
+\ref MEDCoupling::MEDCouplingUMesh::findBoundaryNodes "findBoundaryNodes()" returns all
node ids except the node #4 which is in the middle of \b mesh.
First, we create a 2D mesh with 3 QUAD4 and 2 TRI3 cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getCellIdsLyingOnNodes_1
In the following code we retrieve nodes of the cell #0 an then we call
-\ref ParaMEDMEM::MEDCouplingUMesh::getCellIdsLyingOnNodes "getCellIdsLyingOnNodes()"
+\ref MEDCoupling::MEDCouplingUMesh::getCellIdsLyingOnNodes "getCellIdsLyingOnNodes()"
twice with these nodes and with varying last parameter \b allNodes as input.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getCellIdsLyingOnNodes_2
<br>If the last parameter is \c true
-\ref ParaMEDMEM::MEDCouplingUMesh::getCellIdsLyingOnNodes "getCellIdsLyingOnNodes()" looks
+\ref MEDCoupling::MEDCouplingUMesh::getCellIdsLyingOnNodes "getCellIdsLyingOnNodes()" looks
for cells whose all nodes are given to it, hence it finds the cell #0 only.
<br>If the last parameter is \c false
-\ref ParaMEDMEM::MEDCouplingUMesh::getCellIdsLyingOnNodes "getCellIdsLyingOnNodes()" looks
+\ref MEDCoupling::MEDCouplingUMesh::getCellIdsLyingOnNodes "getCellIdsLyingOnNodes()" looks
for any cell whose nodes are given to it, hence it finds all cells of \b mesh because all
cells share the node #4.
First, we create a 2D mesh with 3 QUAD4 and 2 TRI3 cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getCellIdsFullyIncludedInNodeIds_1
In the following code we retrieve nodes of two cells an then we use
-\ref ParaMEDMEM::MEDCouplingUMesh::getCellIdsFullyIncludedInNodeIds
+\ref MEDCoupling::MEDCouplingUMesh::getCellIdsFullyIncludedInNodeIds
"getCellIdsFullyIncludedInNodeIds()" to find these cells by their nodes.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingUMesh_getCellIdsFullyIncludedInNodeIds_2
\subsubsection cpp_mcpointset_getnodeidsnearpoint Getting nodes close to a point
-The following code creates a 2D \ref ParaMEDMEM::MEDCouplingUMesh
+The following code creates a 2D \ref MEDCoupling::MEDCouplingUMesh
"MEDCouplingUMesh" with 5 nodes and no cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingPointSet_getNodeIdsNearPoint_1
Now we define an array of coordinates of a point close to nodes #0, #2 and #4.
Thus we expect that
-\ref ParaMEDMEM::MEDCouplingPointSet::getNodeIdsNearPoint "getNodeIdsNearPoint()" that
+\ref MEDCoupling::MEDCouplingPointSet::getNodeIdsNearPoint "getNodeIdsNearPoint()" that
we are going to use,
if called with \b eps = 0.003, would return ids of nodes #0, #2 and #4.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingPointSet_getNodeIdsNearPoint_2
\subsubsection cpp_mcpointset_getnodeidsnearpoints Getting nodes close to some points
-The following code creates a 2D \ref ParaMEDMEM::MEDCouplingUMesh
+The following code creates a 2D \ref MEDCoupling::MEDCouplingUMesh
"MEDCouplingUMesh" with 7 nodes and no cells.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingPointSet_getNodeIdsNearPoints_1
Now we define an array of coordinates of 3 points near which we want to find nodes of the mesh.
- Point #2 is close to nodes #3, #4 and #5.
Thus we expect that
-\ref ParaMEDMEM::MEDCouplingPointSet::getNodeIdsNearPoints "getNodeIdsNearPoints()" that
+\ref MEDCoupling::MEDCouplingPointSet::getNodeIdsNearPoints "getNodeIdsNearPoints()" that
we are going to use,
if called with \b eps = 0.003, would return ids of close nodes #1, #3, #4 and #5.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingPointSet_getNodeIdsNearPoints_2
First, we create a mesh with 6 nodes, of which two nodes (#3 and #4) are fully coincident
and 3 nodes (#0, #2 and #5) have distance less than 0.004 between them.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingPointSet_findCommonNodes_1
-Then, we use \ref ParaMEDMEM::MEDCouplingPointSet::findCommonNodes() "findCommonNodes()" to find
+Then, we use \ref MEDCoupling::MEDCouplingPointSet::findCommonNodes() "findCommonNodes()" to find
coincident nodes, and check that (1) calling
-\ref ParaMEDMEM::MEDCouplingPointSet::findCommonNodes() "findCommonNodes()" with \b prec
+\ref MEDCoupling::MEDCouplingPointSet::findCommonNodes() "findCommonNodes()" with \b prec
== 1e-13 finds the two fully coincident nodes only and (2)
-\ref ParaMEDMEM::MEDCouplingPointSet::findCommonNodes() "findCommonNodes"(0.004) finds 5
+\ref MEDCoupling::MEDCouplingPointSet::findCommonNodes() "findCommonNodes"(0.004) finds 5
equal nodes.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingPointSet_findCommonNodes_2
In this example we
- create an 2D mesh and 3 fields on it,
- use
-\ref ParaMEDMEM::MEDCouplingFieldDouble::WriteVTK "WriteVTK()"
+\ref MEDCoupling::MEDCouplingFieldDouble::WriteVTK "WriteVTK()"
to write all the fields and the mesh to a VTK file.
\snippet MEDCouplingExamplesTest.cxx CppSnippet_MEDCouplingFieldDouble_WriteVTK_1
To read it there are 3 main approaches :
-- Use ParaMEDMEM::MEDFileField1TS class :
+- Use MEDCoupling::MEDFileField1TS class :
\snippet MEDLoaderExamplesTest.py PySnippetReadFieldOnAllEntity1_3
-- Use ParaMEDMEM::MEDFileFieldMultiTS class :
+- Use MEDCoupling::MEDFileFieldMultiTS class :
\snippet MEDLoaderExamplesTest.py PySnippetReadFieldOnAllEntity1_4
-- Use iteration ParaMEDMEM::MEDFileFieldMultiTS class :
+- Use iteration MEDCoupling::MEDFileFieldMultiTS class :
\snippet MEDLoaderExamplesTest.py PySnippetReadFieldOnAllEntity1_5
\snippet MEDLoaderExamplesTest.py PySnippetReadFieldPartial1_4
-\ref medcoupling "MEDCoupling" allows to make bridges between the approaches. For example \a pfl \ref ParaMEDMEM::DataArrayInt "DataArrayInt instance" retrieved directly
+\ref medcoupling "MEDCoupling" allows to make bridges between the approaches. For example \a pfl \ref MEDCoupling::DataArrayInt "DataArrayInt instance" retrieved directly
from the file in the second approach can be retrieved starting from first approach.
Starting from mesh \a firstApproachMesh of read field in first approach \a fread, whith the whole mesh \a wholeMesh the profile \a pflComputed can be computed :
For starter, take a look at the \ref MEDLoaderBasicAPIPage "basic MEDLoader API".
\subsubsection f-coher "How to control the validity of my mesh"
-Use the methods \ref ParaMEDMEM::MEDCouplingUMesh::checkCoherency() "MEDCouplingUMesh::checkCoherency()" or
-\ref ParaMEDMEM::MEDCouplingUMesh::checkCoherency1() "MEDCouplingUMesh::checkCoherency1()"
+Use the methods \ref MEDCoupling::MEDCouplingUMesh::checkCoherency() "MEDCouplingUMesh::checkCoherency()" or
+\ref MEDCoupling::MEDCouplingUMesh::checkCoherency1() "MEDCouplingUMesh::checkCoherency1()"
\subsubsection f-groups "How can I read/write groups on a mesh"
Take a look at \ref AdvMEDLoaderAPIMeshReading and \ref AdvMEDLoaderAPIMeshWriting.
\subsubsection f-unstruc "How can I transform a structured mesh into an unstructured one"
-Use the method \ref ParaMEDMEM::MEDCouplingCMesh::buildUnstructured() "MEDCouplingCMesh::buildUnstructured()"
+Use the method \ref MEDCoupling::MEDCouplingCMesh::buildUnstructured() "MEDCouplingCMesh::buildUnstructured()"
\subsection faq-interp Projection, interpolation, remapping
\subsubsection f-proj How to project a field from one mesh to the other
to spot the place where the segfault happens.
The most common source of mistake is some memory mis-allocation and/or deallocation.
With this respect using the auto pointer class
-\ref ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr "MEDCouplingAutoRefCountObjectPtr"
+\ref MEDCoupling::MEDCouplingAutoRefCountObjectPtr "MEDCouplingAutoRefCountObjectPtr"
can be of great help.
\n
MEDCoupling, \ref parallel "ParaMEDMEM", and \ref medloader "MEDLoader" modules so it should be correctly
understood to efficiently deal with \ref meshes "Meshes" and \ref fields "Fields".
-\ref ParaMEDMEM::DataArray "DataArrays" are the atomic element of potentially heavy-memory objects in
+\ref MEDCoupling::DataArray "DataArrays" are the atomic element of potentially heavy-memory objects in
the 3 modules mentionned above.
There are for the moment two types of arrays :
- - double precision float (64 bits) array incarnated by \ref ParaMEDMEM::DataArrayDouble "DataArrayDouble class".
- - signed integer (32 bits) array incarnated by \ref ParaMEDMEM::DataArrayInt "DataArrayInt class".
+ - double precision float (64 bits) array incarnated by \ref MEDCoupling::DataArrayDouble "DataArrayDouble class".
+ - signed integer (32 bits) array incarnated by \ref MEDCoupling::DataArrayInt "DataArrayInt class".
-\ref ParaMEDMEM::DataArrayDouble "DataArrayDouble" and \ref ParaMEDMEM::DataArrayInt "DataArrayInt" classes inherits from
-\ref ParaMEDMEM::DataArray "DataArray" \b non \b instantiable \b class that factorizes some common methods of inherited instantiable classes.
+\ref MEDCoupling::DataArrayDouble "DataArrayDouble" and \ref MEDCoupling::DataArrayInt "DataArrayInt" classes inherits from
+\ref MEDCoupling::DataArray "DataArray" \b non \b instantiable \b class that factorizes some common methods of inherited instantiable classes.
-In the rest of the documentation \b DataArray will be used for both \ref ParaMEDMEM::DataArrayDouble "DataArrayDouble" and \ref ParaMEDMEM::DataArrayInt "DataArrayInt".
+In the rest of the documentation \b DataArray will be used for both \ref MEDCoupling::DataArrayDouble "DataArrayDouble" and \ref MEDCoupling::DataArrayInt "DataArrayInt".
\section MEDCouplingArrayBasics Basics concepts of the DataArrays.
-It will be presented in this section common concept shared by the two classes to \ref ParaMEDMEM::DataArrayDouble "DataArrayDouble" and \ref ParaMEDMEM::DataArrayInt "DataArrayInt".
+It will be presented in this section common concept shared by the two classes to \ref MEDCoupling::DataArrayDouble "DataArrayDouble" and \ref MEDCoupling::DataArrayInt "DataArrayInt".
\subsection MEDCouplingArrayBasicsName Name
-A \ref ParaMEDMEM::DataArray "DataArray" instance has an attribute **name**.
+A \ref MEDCoupling::DataArray "DataArray" instance has an attribute **name**.
-**name** is particularly useful for \ref ParaMEDMEM::DataArray "DataArray" representing profiles, families, groups, fields in MEDLoader.
-But excepted these useful usecases, **name** attribute is often ignored when \ref ParaMEDMEM::DataArray "DataArrays" are aggregated (field array, connectivity, coordinates) in a bigger object.
-Whatever the usage of the **name** attribute of \ref ParaMEDMEM::DataArray "DataArrays", all methods in ParaMEDMEM::DataArrayDouble and ParaMEDMEM::DataArrayInt class deal with **name** as they do for components names.
+**name** is particularly useful for \ref MEDCoupling::DataArray "DataArray" representing profiles, families, groups, fields in MEDLoader.
+But excepted these useful usecases, **name** attribute is often ignored when \ref MEDCoupling::DataArray "DataArrays" are aggregated (field array, connectivity, coordinates) in a bigger object.
+Whatever the usage of the **name** attribute of \ref MEDCoupling::DataArray "DataArrays", all methods in MEDCoupling::DataArrayDouble and MEDCoupling::DataArrayInt class deal with **name** as they do for components names.
\subsection MEDCouplingArrayBasicsTuplesAndCompo Raw data, tuples and components of DataArrays.
-The main goal of \ref ParaMEDMEM::DataArray "DataArray" is to store contiguous vector of atomical elements with same basic datatype (signed integers, double precision...). This vector of atomical elements is called **raw data** of \ref ParaMEDMEM::DataArray "DataArray".
+The main goal of \ref MEDCoupling::DataArray "DataArray" is to store contiguous vector of atomical elements with same basic datatype (signed integers, double precision...). This vector of atomical elements is called **raw data** of \ref MEDCoupling::DataArray "DataArray".
-The size of this vector of data is called <em>"number of elements"</em>. So the number of bytes stored by a \ref ParaMEDMEM::DataArray "DataArray" instance, is equal to
+The size of this vector of data is called <em>"number of elements"</em>. So the number of bytes stored by a \ref MEDCoupling::DataArray "DataArray" instance, is equal to
the product of the __number of elements__ * __constant size of DataType__ .
-As \ref ParaMEDMEM::DataArray "DataArray" instances are designed to store vector fields, tensor fields, coordinate of nodes, the notion of _components_ has been added.
+As \ref MEDCoupling::DataArray "DataArray" instances are designed to store vector fields, tensor fields, coordinate of nodes, the notion of _components_ has been added.
-So, \ref ParaMEDMEM::DataArray "DataArrays" have an additional attribute that is number of components that represent the size of a contiguous set of atomical elements.
-The vector of atomical elements stored into \ref ParaMEDMEM::DataArray "DataArrays" are grouped in contiguous memory set of atomical elements having each same size.
+So, \ref MEDCoupling::DataArray "DataArrays" have an additional attribute that is number of components that represent the size of a contiguous set of atomical elements.
+The vector of atomical elements stored into \ref MEDCoupling::DataArray "DataArrays" are grouped in contiguous memory set of atomical elements having each same size.
The contiguous set of atomical elements is called **tuple**. And each **tuple** stored in raw data, has a length exactly equal to the number of components of
-\ref ParaMEDMEM::DataArray "DataArray" storing it.
+\ref MEDCoupling::DataArray "DataArray" storing it.
Thus :
N_{bytes}=N_{elements}*sizeof(DataType)=N_{tuples}*N_{components}*sizeof(DataType).
\f]
-In other words, **raw data** of \ref ParaMEDMEM::DataArray "DataArrays" can be seen as a dense matrix, whose number of components would be the row size and number of tuples
-would be the column size. In this point of view of \ref ParaMEDMEM::DataArray "DataArrays" a **tuple** is represented by the corresponding row in the dense matrix.
+In other words, **raw data** of \ref MEDCoupling::DataArray "DataArrays" can be seen as a dense matrix, whose number of components would be the row size and number of tuples
+would be the column size. In this point of view of \ref MEDCoupling::DataArray "DataArrays" a **tuple** is represented by the corresponding row in the dense matrix.
-Typically in the **raw data** of \ref ParaMEDMEM::DataArray "DataArrays" **number of tuples** is highly bigger than **number of components** !
+Typically in the **raw data** of \ref MEDCoupling::DataArray "DataArrays" **number of tuples** is highly bigger than **number of components** !
To finish, raw data is stored tuples by tuples, in another words, in **full interlace mode**, which is the natural storage strategy in C/C++ world.
\subsection MEDCouplingArrayBasicsCompoName Information on components name.
-As seen in the sub section above, a \ref ParaMEDMEM::DataArray "DataArray" instance has a defined number of components.
+As seen in the sub section above, a \ref MEDCoupling::DataArray "DataArray" instance has a defined number of components.
-There is an information attached to each of these components constituting the \ref ParaMEDMEM::DataArray "DataArray".
+There is an information attached to each of these components constituting the \ref MEDCoupling::DataArray "DataArray".
This information is concretely a string of characters that allows, if needed, to give information about the corresponding component.
\subsection MEDCouplingArrayBasicsTimeLabel DataArrays and TimeLabel.
-\ref ParaMEDMEM::DataArray "DataArrays instances" can consume big amount of data in memory so they inherit from \ref MEDCouplingTimeLabelPage "TimeLabel".
+\ref MEDCoupling::DataArray "DataArrays instances" can consume big amount of data in memory so they inherit from \ref MEDCouplingTimeLabelPage "TimeLabel".
So in C++ it is a good practice to use :
- \c getConstPointer method in readonly access.
- \c getPointer method only if write is needed.
-If the user in C++ or Python wants to modify intensively its **big** \ref ParaMEDMEM::DataArray "DataArray" instance **not** using raw data pointer it is better to invoke
-\c setIJSilent just after invocation of \c declareAsNew instead of calling \c setIJ method that will increment time label of \ref ParaMEDMEM::DataArray "DataArray" instance
+If the user in C++ or Python wants to modify intensively its **big** \ref MEDCoupling::DataArray "DataArray" instance **not** using raw data pointer it is better to invoke
+\c setIJSilent just after invocation of \c declareAsNew instead of calling \c setIJ method that will increment time label of \ref MEDCoupling::DataArray "DataArray" instance
on each call.
\c setIJ method usage should be reduced to little modification sessions.
\section MEDCouplingArrayBuildFromScratch Building an array from scratch
-Here is a description of typical usages of \ref ParaMEDMEM::DataArrayDouble "MEDCoupling arrays".
+Here is a description of typical usages of \ref MEDCoupling::DataArrayDouble "MEDCoupling arrays".
\if ENABLE_EXAMPLES
\ref MEDCouplingArraySteps1 "Here is a C++ example."<br>
\section MEDCouplingArrayBasicsCopy Copy DataArrays
-As \ref ParaMEDMEM::DataArray "DataArrays" are the atomic entity of potentially big memory objects into \ref medcoupling "MEDCoupling"
-, \ref ParaMEDMEM::DataArray "DataArrays" introduces concepts of copy and comparison that will be used by aggregating classes.
+As \ref MEDCoupling::DataArray "DataArrays" are the atomic entity of potentially big memory objects into \ref medcoupling "MEDCoupling"
+, \ref MEDCoupling::DataArray "DataArrays" introduces concepts of copy and comparison that will be used by aggregating classes.
For more complex objects (that aggregate themselves big objects)
-like ParaMEDMEM::MEDCouplingFieldDouble the concept of copy (shallow or deep) is less straight forward because which aggregated subobjects are copied or not.
+like MEDCoupling::MEDCouplingFieldDouble the concept of copy (shallow or deep) is less straight forward because which aggregated subobjects are copied or not.
\subsection MEDCouplingArrayBasicsCopyDeep Deep copy of DataArray
-As for all potentially heavy memory consumer objects in \ref medcoupling "MEDCoupling", \ref ParaMEDMEM::DataArray "DataArrays" implement
+As for all potentially heavy memory consumer objects in \ref medcoupling "MEDCoupling", \ref MEDCoupling::DataArray "DataArrays" implement
method \c deepCpy. This method deeply copies an instance. The life cycle of the returned object is *fully* independent from the instance on which the method
\c deepCpy has been invoked.
\subsection MEDCouplingArrayBasicsCopyShallow Shallow copy of DataArray
-As \ref ParaMEDMEM::DataArray "DataArrays" are the atomic entity of potentially big memory objects into \ref medcoupling "MEDCoupling", the shallow copy
+As \ref MEDCoupling::DataArray "DataArrays" are the atomic entity of potentially big memory objects into \ref medcoupling "MEDCoupling", the shallow copy
simply returns the same object with the reference counter incremented.
\if ENABLE_EXAMPLES
There are two types of comparison :
- strict, that compares strictly all the non mutable attributes (state sensitive). Methods to perform this strict comparison are :
- - ParaMEDMEM::DataArrayInt::isEqual
- - ParaMEDMEM::DataArrayDouble::isEqual.
+ - MEDCoupling::DataArrayInt::isEqual
+ - MEDCoupling::DataArrayDouble::isEqual.
- less strict, that focus only on non string attributes. Methods to perform less strict comparison are :
- - ParaMEDMEM::DataArrayInt::isEqualWithoutConsideringStr
- - ParaMEDMEM::DataArrayDouble::isEqualWithoutConsideringStr
+ - MEDCoupling::DataArrayInt::isEqualWithoutConsideringStr
+ - MEDCoupling::DataArrayDouble::isEqualWithoutConsideringStr
\section MEDCouplingArrayFill Filling DataArray with values
Both DataArrayDouble and DataArrayInt provide comfort methods that
fill the array with some values. These methods are:
-- ParaMEDMEM::DataArrayInt::fillWithZero and
- ParaMEDMEM::DataArrayDouble::fillWithZero which assigns zero to all
+- MEDCoupling::DataArrayInt::fillWithZero and
+ MEDCoupling::DataArrayDouble::fillWithZero which assigns zero to all
values in array.
-- ParaMEDMEM::DataArrayInt::fillWithValue and
- ParaMEDMEM::DataArrayDouble::fillWithValue which assigns a certain value to all
+- MEDCoupling::DataArrayInt::fillWithValue and
+ MEDCoupling::DataArrayDouble::fillWithValue which assigns a certain value to all
values in array.
-- ParaMEDMEM::DataArrayInt::iota() and
- ParaMEDMEM::DataArrayDouble::iota() which assigns incrementing values to all
+- MEDCoupling::DataArrayInt::iota() and
+ MEDCoupling::DataArrayDouble::iota() which assigns incrementing values to all
values in array.
\section MEDCouplingArrayApplyFunc Application of a function on DataArrayDouble instances.
-This section is only dedicated for \ref ParaMEDMEM::DataArrayDouble "DataArrayDouble instances".
+This section is only dedicated for \ref MEDCoupling::DataArrayDouble "DataArrayDouble instances".
-It is possible to apply to \ref ParaMEDMEM::DataArrayDouble "DataArrayDouble instance" a function given by a string.
+It is possible to apply to \ref MEDCoupling::DataArrayDouble "DataArrayDouble instance" a function given by a string.
-There are different API for applyFunc* methods of \ref ParaMEDMEM::DataArrayDouble "DataArrayDouble class".
+There are different API for applyFunc* methods of \ref MEDCoupling::DataArrayDouble "DataArrayDouble class".
\subsection MEDCouplingArrayApplyFuncExpr Expressions supported
\subsection MEDCouplingArrayApplyFunc0 applyFunc method with only one parameter
This method produces a newly allocated DataArrayDouble instance having exactly the same number of components **and** number of tuples than the instance on which the
-\ref ParaMEDMEM::DataArrayDouble::applyFunc(const std::string &, bool) const applyFunc method is applied.
+\ref MEDCoupling::DataArrayDouble::applyFunc(const std::string &, bool) const applyFunc method is applied.
**This method is useful when the evaluation expression do not need to consider the components of each tuple separately**.
-That's why this method of \ref ParaMEDMEM::DataArrayDouble::applyFunc(const std::string &, bool) const applyFunc method with one parameter accepts at most only one variable.
+That's why this method of \ref MEDCoupling::DataArrayDouble::applyFunc(const std::string &, bool) const applyFunc method with one parameter accepts at most only one variable.
If it is not the case an exception is thrown as seen here :
As the example shows, the output \c d1 has 2 components as \c d.
-Whereas all the components of the input of \c d be not considered separately, it is also, possible with \ref ParaMEDMEM::DataArrayDouble::applyFunc(const std::string &, bool) const applyFunc method with one parameter
+Whereas all the components of the input of \c d be not considered separately, it is also, possible with \ref MEDCoupling::DataArrayDouble::applyFunc(const std::string &, bool) const applyFunc method with one parameter
to build an output having same number of components than input but where components in input are treated separately.
Let's build an example using DataArrayDouble instance \c d defined just above.
\subsection MEDCouplingArrayApplyFunc1 applyFunc method with only two parameters
-This method also returns a newly allocated DataArrayDouble instance having the same number of tuples than the DataArrayDouble instance on which \ref ParaMEDMEM::DataArrayDouble::applyFunc(int,const std::string &, bool) const applyFunc method is called, but the contrary to previous \ref MEDCouplingArrayApplyFunc0 "applyFunc with one parameter version" here the number of components is set by the user.
+This method also returns a newly allocated DataArrayDouble instance having the same number of tuples than the DataArrayDouble instance on which \ref MEDCoupling::DataArrayDouble::applyFunc(int,const std::string &, bool) const applyFunc method is called, but the contrary to previous \ref MEDCouplingArrayApplyFunc0 "applyFunc with one parameter version" here the number of components is set by the user.
The big difference with \ref MEDCouplingArrayApplyFunc0 "applyFunc method with one parameter" seen above is that here components of tuples are treated separately.
-The method that implements it is \ref ParaMEDMEM::DataArrayDouble::applyFunc(int,const std::string &, bool) const here.
+The method that implements it is \ref MEDCoupling::DataArrayDouble::applyFunc(int,const std::string &, bool) const here.
-Here the number of variables appearing in the expression should be equal at most to the number of component of the DataArrayDouble instance on which \ref ParaMEDMEM::DataArrayDouble::applyFunc(int,const std::string &, bool) const applyFunc method is called.
+Here the number of variables appearing in the expression should be equal at most to the number of component of the DataArrayDouble instance on which \ref MEDCoupling::DataArrayDouble::applyFunc(int,const std::string &, bool) const applyFunc method is called.
Let's consider the following DataArrayDouble having 4 tuples with 3 components called dd.
of \c dd.
\n
The expression \c "a+c" will add component #0 to component #1 as seen in warning section !!!! It can appear silly, but this strategy has been chosen in order to support different set of variables.
-\n \ref ParaMEDMEM::DataArrayDouble::applyFunc2 "applyFunc2" and \ref ParaMEDMEM::DataArrayDouble::applyFunc3 "applyFunc3" methods have been developed to remedy to that feature that can be surprising.
+\n \ref MEDCoupling::DataArrayDouble::applyFunc2 "applyFunc2" and \ref MEDCoupling::DataArrayDouble::applyFunc3 "applyFunc3" methods have been developed to remedy to that feature that can be surprising.
\n These two methods are explained respectively \ref MEDCouplingArrayApplyFunc2 "here for applyFunc2" and \ref MEDCouplingArrayApplyFunc3 "here for applyFunc3".
-Whatever it is possible to find a workaround using \ref ParaMEDMEM::DataArrayDouble::applyFunc(int,const std::string &, bool) const applyFunc with 2 parameters.
+Whatever it is possible to find a workaround using \ref MEDCoupling::DataArrayDouble::applyFunc(int,const std::string &, bool) const applyFunc with 2 parameters.
\n Here is a solution to compute \c dd2 :
\snippet MEDCouplingExamplesTest.py PySnippetDataArrayApplyFunc1_6
\subsection MEDCouplingArrayApplyFunc2 applyFunc2 method
-The method that implements it is \ref ParaMEDMEM::DataArrayDouble::applyFunc2 here.
+The method that implements it is \ref MEDCoupling::DataArrayDouble::applyFunc2 here.
This method is very close to \ref MEDCouplingArrayApplyFunc1 "applyFunc method with only two parameters".
\subsection MEDCouplingArrayApplyFunc3 applyFunc3 method
-The method that implements it is \ref ParaMEDMEM::DataArrayDouble::applyFunc3 here.
+The method that implements it is \ref MEDCoupling::DataArrayDouble::applyFunc3 here.
This method is very close to \ref MEDCouplingArrayApplyFunc1 "applyFunc method with only two parameters" and \ref MEDCouplingArrayApplyFunc2 "applyFunc2".
\page numbering Array indexing and numbering
The MED library make constant use of arrays of integer or double to represent the various
-data it needs. The arrays of integer (\ref ParaMEDMEM::DataArrayInt "DataArrayInt") are of special importance as they
+data it needs. The arrays of integer (\ref MEDCoupling::DataArrayInt "DataArrayInt") are of special importance as they
often constitutes the return value of the functions provided by the API. This can be
a list of nodes, a list of cells, a way to rearrange the cell in a mesh (a permutation), a part of the
domain when doing parallel computation, etc ...
Formally a "renumbering" is a mathematical application that can be surjective, injective or bijective.
This application is defined using an instance of
-\ref ParaMEDMEM::DataArrayInt "DataArrayInt". There are different ways to define this application.
+\ref MEDCoupling::DataArrayInt "DataArrayInt". There are different ways to define this application.
\section MEDCouplingArrayRenumberingO2N Old-to-new mode
The old to new mode is particularly recommanded for surjective and bijective applications. This
-is typically the case of \ref ParaMEDMEM::MEDCouplingUMesh::mergeNodes "MEDCouplingUMesh::mergeNodes" method.
-Let's consider a call to \ref ParaMEDMEM::MEDCouplingUMesh::mergeNodes "mergeNodes" that reduces the
+is typically the case of \ref MEDCoupling::MEDCouplingUMesh::mergeNodes "MEDCouplingUMesh::mergeNodes" method.
+Let's consider a call to \ref MEDCoupling::MEDCouplingUMesh::mergeNodes "mergeNodes" that reduces the
number of nodes from 5 nodes to 3 nodes.\n
In old to new mode the array \b MySurjection that specifies this surjection will have 5 tuples
and 1 component. The content of the 5*1 values will be in {0,1,2}.\n
Method in old to new mode that works on bijective applications :
-- \ref ParaMEDMEM::DataArrayDouble::renumber "DataArrayDouble::renumber"
-- \ref ParaMEDMEM::DataArrayDouble::renumberInPlace "DataArrayDouble::renumberInPlace"
+- \ref MEDCoupling::DataArrayDouble::renumber "DataArrayDouble::renumber"
+- \ref MEDCoupling::DataArrayDouble::renumberInPlace "DataArrayDouble::renumberInPlace"
Method in old to new mode that works on surjective applications :
-- \ref ParaMEDMEM::DataArrayDouble::renumberAndReduce "DataArrayDouble::renumberAndReduce"
+- \ref MEDCoupling::DataArrayDouble::renumberAndReduce "DataArrayDouble::renumberAndReduce"
Sometimes the format old to new for surjections can be replaced by another format with 2 arrays.
-Less compact in memory. The \ref ParaMEDMEM::DataArrayInt::changeSurjectiveFormat "DataArrayInt::changeSurjectiveFormat" method performs that.
+Less compact in memory. The \ref MEDCoupling::DataArrayInt::changeSurjectiveFormat "DataArrayInt::changeSurjectiveFormat" method performs that.
\section MEDCouplingArrayRenumberingN2O New-to-old mode
The new-to-old mode is particularly recommended for strictly injective and bijective permutations.
This is particularly useful for methods that increase the number of entities like for example
-\ref ParaMEDMEM::MEDCouplingUMesh::simplexize "MEDCouplingUMesh::simplexize".\n
-All non static methods in \ref ParaMEDMEM::DataArrayDouble "DataArrayDouble"
-or \ref ParaMEDMEM::DataArrayInt "DataArrayInt" having as last letter \b R (meaning Reversed) in
+\ref MEDCoupling::MEDCouplingUMesh::simplexize "MEDCouplingUMesh::simplexize".\n
+All non static methods in \ref MEDCoupling::DataArrayDouble "DataArrayDouble"
+or \ref MEDCoupling::DataArrayInt "DataArrayInt" having as last letter \b R (meaning Reversed) in
capital works with the mode new to old.
-Let's consider a call to \ref ParaMEDMEM::MEDCouplingUMesh::simplexize "simplexize" that increases
+Let's consider a call to \ref MEDCoupling::MEDCouplingUMesh::simplexize "simplexize" that increases
the number of cell from 4 cells to 6 cells.\n
In new-to-old mode the array \b MyInjection that specifies this injection will have 6 tuples
and 1 component. The content of the 5*1 values will be in {0,1,2,3}.\n
Method in new-to-old mode that works on bijective applications :
-- \ref ParaMEDMEM::DataArrayDouble::renumberR "DataArrayDouble::renumberR"
-- \ref ParaMEDMEM::DataArrayDouble::renumberInPlace "DataArrayDouble::renumberInPlaceR"
+- \ref MEDCoupling::DataArrayDouble::renumberR "DataArrayDouble::renumberR"
+- \ref MEDCoupling::DataArrayDouble::renumberInPlace "DataArrayDouble::renumberInPlaceR"
Method in new-to-old mode that works on surjective applications :
-- \ref ParaMEDMEM::DataArrayDouble::selectByTupleId "DataArrayDouble::selectByTupleId"
-- \ref ParaMEDMEM::DataArrayDouble::selectByTupleIdSafe "DataArrayDouble::selectByTupleIdSafe"
-- \ref ParaMEDMEM::DataArrayDouble::selectByTupleId2 "DataArrayDouble::selectByTupleId2"
-- \ref ParaMEDMEM::DataArrayDouble::selectByTupleRanges "DataArrayDouble::selectByTupleRanges"
+- \ref MEDCoupling::DataArrayDouble::selectByTupleId "DataArrayDouble::selectByTupleId"
+- \ref MEDCoupling::DataArrayDouble::selectByTupleIdSafe "DataArrayDouble::selectByTupleIdSafe"
+- \ref MEDCoupling::DataArrayDouble::selectByTupleId2 "DataArrayDouble::selectByTupleId2"
+- \ref MEDCoupling::DataArrayDouble::selectByTupleRanges "DataArrayDouble::selectByTupleRanges"
\section numbering-indirect Indirect indexing
This format is widely used internally (this is how the connectivity of
\ref MEDCouplingUMeshPage "unstructured cells" is stored for example), and is also returned by
many functions, e.g.:
-- \ref ParaMEDMEM::MEDCouplingPointSet::findCommonCells "MEDCouplingPointSet::findCommonCells"
-- \ref ParaMEDMEM::MEDCouplingPointSet::findCommonNodes "MEDCouplingPointSet::findCommonNodes"
-- \ref ParaMEDMEM::MEDCouplingPointSet::getNodeIdsNearPoints "MEDCouplingPointSet::getNodeIdsNearPoints"
-- \ref ParaMEDMEM::MEDCouplingUMesh::buildDescendingConnectivity "MEDCouplingUMesh::buildDescendingConnectivity"
-- \ref ParaMEDMEM::MEDCouplingUMesh::computeNeighborsOfNodes "MEDCouplingUMesh::computeNeighborsOfNodes"
-- \ref ParaMEDMEM::MEDCouplingUMesh::convertNodalConnectivityToDynamicGeoTypeMesh "MEDCouplingUMesh::convertNodalConnectivityToDynamicGeoTypeMesh"
-- \ref ParaMEDMEM::MEDCouplingUMesh::setConnectivity "MEDCouplingUMesh::setConnectivity"
-- \ref ParaMEDMEM::MEDCouplingUMesh::split2DCells "MEDCouplingUMesh::split2DCells"
+- \ref MEDCoupling::MEDCouplingPointSet::findCommonCells "MEDCouplingPointSet::findCommonCells"
+- \ref MEDCoupling::MEDCouplingPointSet::findCommonNodes "MEDCouplingPointSet::findCommonNodes"
+- \ref MEDCoupling::MEDCouplingPointSet::getNodeIdsNearPoints "MEDCouplingPointSet::getNodeIdsNearPoints"
+- \ref MEDCoupling::MEDCouplingUMesh::buildDescendingConnectivity "MEDCouplingUMesh::buildDescendingConnectivity"
+- \ref MEDCoupling::MEDCouplingUMesh::computeNeighborsOfNodes "MEDCouplingUMesh::computeNeighborsOfNodes"
+- \ref MEDCoupling::MEDCouplingUMesh::convertNodalConnectivityToDynamicGeoTypeMesh "MEDCouplingUMesh::convertNodalConnectivityToDynamicGeoTypeMesh"
+- \ref MEDCoupling::MEDCouplingUMesh::setConnectivity "MEDCouplingUMesh::setConnectivity"
+- \ref MEDCoupling::MEDCouplingUMesh::split2DCells "MEDCouplingUMesh::split2DCells"
Some functions in the API to manipulate this format:
-- \ref ParaMEDMEM::DataArrayInt::changeSurjectiveFormat "DataArrayInt::changeSurjectiveFormat"
-- \ref ParaMEDMEM::MEDCouplingUMesh::ExtractFromIndexedArrays "(static) MEDCouplingUMesh::ExtractFromIndexedArrays"
-- \ref ParaMEDMEM::MEDCouplingUMesh::ExtractFromIndexedArrays2 "(static) MEDCouplingUMesh::ExtractFromIndexedArrays2"
+- \ref MEDCoupling::DataArrayInt::changeSurjectiveFormat "DataArrayInt::changeSurjectiveFormat"
+- \ref MEDCoupling::MEDCouplingUMesh::ExtractFromIndexedArrays "(static) MEDCouplingUMesh::ExtractFromIndexedArrays"
+- \ref MEDCoupling::MEDCouplingUMesh::ExtractFromIndexedArrays2 "(static) MEDCouplingUMesh::ExtractFromIndexedArrays2"
*/
\ No newline at end of file
\page MEDCouplingTimeLabelPage Time label in MEDCoupling
Time label is a **non instantiable** class whose each object consuming potentially big amount of memory inherits from.
-The class that incarnates this concept is ParaMEDMEM::TimeLabel.
+The class that incarnates this concept is MEDCoupling::TimeLabel.
-Here are some of examples of classes that inherit from \ref ParaMEDMEM::TimeLabel "TimeLabel" class :
+Here are some of examples of classes that inherit from \ref MEDCoupling::TimeLabel "TimeLabel" class :
-- ParaMEDMEM::DataArrayInt, ParaMEDMEM::DataArrayDouble
-- ParaMEDMEM::MEDCouplingMesh
-- ParaMEDMEM::MEDCouplingFieldDouble
+- MEDCoupling::DataArrayInt, MEDCoupling::DataArrayDouble
+- MEDCoupling::MEDCouplingMesh
+- MEDCoupling::MEDCouplingFieldDouble
- ...
This class is in charge of storing a 32 bits unsigned integer called the time label, that allows the user to know easily, if an heavy object in memory has been modified or not.
The usage is simple :
-- Call ParaMEDMEM::TimeLabel::getTimeOfThis a first time to retrieve a reference. Store the returned unsigned integer.
-- When you need to know if the instance inheriting from ParaMEDMEM::TimeLabel has changed or not simply invoke ParaMEDMEM::TimeLabel::getTimeOfThis again and compare with the stored value.
+- Call MEDCoupling::TimeLabel::getTimeOfThis a first time to retrieve a reference. Store the returned unsigned integer.
+- When you need to know if the instance inheriting from MEDCoupling::TimeLabel has changed or not simply invoke MEDCoupling::TimeLabel::getTimeOfThis again and compare with the stored value.
If the value is different, the instance has changed, if not the instance has **not** changed.
-The virtual call to ParaMEDMEM::TimeLabel::updateTime changes the behaviour of ParaMEDMEM::TimeLabel::getTimeOfThis ; it is a bug, so please notify the bug on the SALOME forum.
+The virtual call to MEDCoupling::TimeLabel::updateTime changes the behaviour of MEDCoupling::TimeLabel::getTimeOfThis ; it is a bug, so please notify the bug on the SALOME forum.
*/
Using the C++ API provided by MED requires you to be familiar with some specificities which are not
visible to the Python user.
-- \ref ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr "MEDCouplingAutoRefCountObjectPtr"
+- \ref MEDCoupling::MEDCouplingAutoRefCountObjectPtr "MEDCouplingAutoRefCountObjectPtr"
- \subpage MEDCouplingTimeLabelPage
-\b Note: all the standard (sequential) MEDCoupling API lies in the \ref ParaMEDMEM "ParaMEDMEM namespace".
+\b Note: all the standard (sequential) MEDCoupling API lies in the \ref MEDCoupling "MEDCoupling namespace".
This is quite unfortunate but due to historical reasons. The true parallel functionalities
of the \ref library "MED library" are detailed here: \ref parallel
The memory management of the various strucutres is eased by the class
-\ref ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr "MEDCouplingAutoRefCountObjectPtr". It acts as an auto pointer and takes care of deleting the
+\ref MEDCoupling::MEDCouplingAutoRefCountObjectPtr "MEDCouplingAutoRefCountObjectPtr". It acts as an auto pointer and takes care of deleting the
memory automatically when going out of scope. See an example usage in \ref cpp_mcfielddouble_WriteVTK .
Beware however that not all functions return a pointer that should be deleted when going out of scope.
-Some methods only return an observer to the data, see for example \ref ParaMEDMEM::MEDCouplingPointSet::getCoords() "getCoords()". The API documentation of each method indicates whether the caller is responsible of the returned
+Some methods only return an observer to the data, see for example \ref MEDCoupling::MEDCouplingPointSet::getCoords() "getCoords()". The API documentation of each method indicates whether the caller is responsible of the returned
data or not.
For advanced usage, one has to be aware of the stamping mechanism used internally to know
They are directly related to the equivalent class in MEDCoupling, without the string \c Servant at the end of the
name:
-- \ref ParaMEDMEM::DataArrayDoubleServant "DataArrayDoubleServant"
-- \ref ParaMEDMEM::DataArrayIntServant "DataArrayIntServant"
-- \ref ParaMEDMEM::MEDCouplingUMeshServant "MEDCouplingUMeshServant"
-- \ref ParaMEDMEM::MEDCouplingCMeshServant "MEDCouplingCMeshServant"
-- \ref ParaMEDMEM::MEDCouplingFieldDoubleServant "MEDCouplingFieldDoubleServant"
+- \ref MEDCoupling::DataArrayDoubleServant "DataArrayDoubleServant"
+- \ref MEDCoupling::DataArrayIntServant "DataArrayIntServant"
+- \ref MEDCoupling::MEDCouplingUMeshServant "MEDCouplingUMeshServant"
+- \ref MEDCoupling::MEDCouplingCMeshServant "MEDCouplingCMeshServant"
+- \ref MEDCoupling::MEDCouplingFieldDoubleServant "MEDCouplingFieldDoubleServant"
TODO: complete the list.
- \ref ParaMESH-det "ParaMESH", the parallel instanciation of a \ref meshes "MEDCoupling mesh"
- \ref ParaFIELD-det "ParaFIELD", the parallel instanciation of a \ref fields "MEDCoupling field"
- \ref MPIProcessorGroup-det "MPIProcessorGroup" (which inherits from the abstract
-\ref ParaMEDMEM::ProcessorGroup "ProcessorGroup"), a group of processors (typically MPI nodes)
+\ref MEDCoupling::ProcessorGroup "ProcessorGroup"), a group of processors (typically MPI nodes)
In an advanced usage, the topology of the nodes in the computation is accessed through the following elements:
- \ref BlockTopology-det "BlockTopology", specification of a topology based on the (structured) mesh.
it works in a similar fashion than what the \ref remapper "sequential remapper" does.
- \b NonCoincidentDEC (deprecated for now)
-Besides, all the DECs inherit from the class \ref ParaMEDMEM::DECOptions "DECOptions" which provides
+Besides, all the DECs inherit from the class \ref MEDCoupling::DECOptions "DECOptions" which provides
the necessary methods to adjust the parameters used in the transfer/remapping.
The most commonly used %DEC is the \c %InterpKernelDEC, and here is a simple example to of its usage:
This definition of field in MEDCoupling allows an instance of field to
know at any point inside its spatial-temporal support the value.
-The class that incarnates the concept described above is : \ref ParaMEDMEM::MEDCouplingFieldDouble.
+The class that incarnates the concept described above is : \ref MEDCoupling::MEDCouplingFieldDouble.
Some of most important implemented methods are :
-- \ref ParaMEDMEM::MEDCouplingFieldDouble::getNumberOfComponents "getNumberOfComponents"
-- \ref ParaMEDMEM::MEDCouplingFieldDouble::getValueOn "getValueOn"
-- \ref ParaMEDMEM::MEDCouplingFieldDouble::applyFunc "applyFunc"
-- \ref ParaMEDMEM::MEDCouplingFieldDouble::AddFields "cross instances operations"
+- \ref MEDCoupling::MEDCouplingFieldDouble::getNumberOfComponents "getNumberOfComponents"
+- \ref MEDCoupling::MEDCouplingFieldDouble::getValueOn "getValueOn"
+- \ref MEDCoupling::MEDCouplingFieldDouble::applyFunc "applyFunc"
+- \ref MEDCoupling::MEDCouplingFieldDouble::AddFields "cross instances operations"
\section MEDCouplingSpatialDisc Spatial discretization concept
This is the concept that makes the link, independently from temporal
concept allows the field to make a check and interpretation of an
array of values given a spatial support (\ref meshes "mesh").
-The abstract class that incarnates the concept is : \ref ParaMEDMEM::MEDCouplingFieldDiscretization.
+The abstract class that incarnates the concept is : \ref MEDCoupling::MEDCouplingFieldDiscretization.
The most important pure virtual methods are :
-- \ref ParaMEDMEM::MEDCouplingFieldDiscretization::getNumberOfTuples "getnumberOfTuples"
-- \ref ParaMEDMEM::MEDCouplingFieldDiscretization::getValueOn "getValueOn"
-- \ref ParaMEDMEM::MEDCouplingFieldDiscretization::getMeasureField "getMeasureField"
+- \ref MEDCoupling::MEDCouplingFieldDiscretization::getNumberOfTuples "getnumberOfTuples"
+- \ref MEDCoupling::MEDCouplingFieldDiscretization::getValueOn "getValueOn"
+- \ref MEDCoupling::MEDCouplingFieldDiscretization::getMeasureField "getMeasureField"
\section MEDCouplingTemporalDisc Temporal discretization concept
defined. This concept is able to give the value at any time of
the definition interval (if any).
-The abstract class \ref ParaMEDMEM::MEDCouplingTimeDiscretization
+The abstract class \ref MEDCoupling::MEDCouplingTimeDiscretization
incarnates this described concept.
This classes and its subclasses are responsible in storing the arrays
The most important methods are :
-- \ref ParaMEDMEM::MEDCouplingTimeDiscretization::setTime "setTime" and \ref ParaMEDMEM::MEDCouplingTimeDiscretization::getTime "getTime"
-- \ref ParaMEDMEM::MEDCouplingTimeDiscretization::getArray "getArray" and \ref ParaMEDMEM::MEDCouplingTimeDiscretization::setArray "setArray"
-- \ref ParaMEDMEM::MEDCouplingTimeDiscretization::getArraysForTime "getArraysForTime"
-- \ref ParaMEDMEM::MEDCouplingTimeDiscretization::getValueForTime "getValueForTime"
+- \ref MEDCoupling::MEDCouplingTimeDiscretization::setTime "setTime" and \ref MEDCoupling::MEDCouplingTimeDiscretization::getTime "getTime"
+- \ref MEDCoupling::MEDCouplingTimeDiscretization::getArray "getArray" and \ref MEDCoupling::MEDCouplingTimeDiscretization::setArray "setArray"
+- \ref MEDCoupling::MEDCouplingTimeDiscretization::getArraysForTime "getArraysForTime"
+- \ref MEDCoupling::MEDCouplingTimeDiscretization::getValueForTime "getValueForTime"
\section MEDCouplingFirstSteps3 Building a field from scratch
\section MEDCouplingSecondStep0 Operations on Fields
-Here we will make the assumption that an instance of \ref ParaMEDMEM::MEDCouplingMesh "MEDCouplingMesh"
+Here we will make the assumption that an instance of \ref MEDCoupling::MEDCouplingMesh "MEDCouplingMesh"
called \c mesh has been created with spaceDim==2.
\ref medcouplingcppexamplesFieldDoubleBuild5 "Here a C++ example of more advanced use of MEDCouplingFieldDouble instances".
\section field-space Spatial discretization
A field can be supported by:
- the nodes (vertices) of the mesh: this is built with the
-\ref ParaMEDMEM::TypeOfField "ON_NODES" keyword in the
-\ref ParaMEDMEM::MEDCouplingFieldDouble::New(TypeOfField , TypeOfTimeDiscretization) "constructor of a field".
+\ref MEDCoupling::TypeOfField "ON_NODES" keyword in the
+\ref MEDCoupling::MEDCouplingFieldDouble::New(TypeOfField , TypeOfTimeDiscretization) "constructor of a field".
- the cells (or "elements") of the mesh: built with the
-\ref ParaMEDMEM::TypeOfField "ON_CELLS" keyword in the
-\ref ParaMEDMEM::MEDCouplingFieldDouble::New(TypeOfField , TypeOfTimeDiscretization) "constructor of a field".
+\ref MEDCoupling::TypeOfField "ON_CELLS" keyword in the
+\ref MEDCoupling::MEDCouplingFieldDouble::New(TypeOfField , TypeOfTimeDiscretization) "constructor of a field".
- or more complex items:
- - Gauss points: built with \ref ParaMEDMEM::TypeOfField "ON_GAUSS_PT"
- - Gauss points on nodes per element: built with \ref ParaMEDMEM::TypeOfField "ON_GAUSS_NE"
- - Kriging points: built with \ref ParaMEDMEM::TypeOfField "ON_NODES_KR"
+ - Gauss points: built with \ref MEDCoupling::TypeOfField "ON_GAUSS_PT"
+ - Gauss points on nodes per element: built with \ref MEDCoupling::TypeOfField "ON_GAUSS_NE"
+ - Kriging points: built with \ref MEDCoupling::TypeOfField "ON_NODES_KR"
The spatial discretization is at the center of the \ref interpolation "interpolation" mechanisms,
since one of the main interpolation paramter is indeed specifying from which source discretization
- a P1->P0 interpolation means that a field on nodes this time will be transfered to a cell-based field.
- etc ...
-Finally, in the code itself, the class \ref ParaMEDMEM::MEDCouplingFieldDiscretization "MEDCouplingFieldDiscretization"
+Finally, in the code itself, the class \ref MEDCoupling::MEDCouplingFieldDiscretization "MEDCouplingFieldDiscretization"
is the concrete representation of this concept.
\section field-time Temporal discretization
Similarly to the spatial discretization, a field object in MEDCoupling has a time discretization
representing the time range that is covered by the data. It is also specified in the
-\ref ParaMEDMEM::MEDCouplingFieldDouble::New(TypeOfField , TypeOfTimeDiscretization) "constructor of a field".
+\ref MEDCoupling::MEDCouplingFieldDouble::New(TypeOfField , TypeOfTimeDiscretization) "constructor of a field".
It can be one of:
-- \ref ParaMEDMEM::TypeOfTimeDiscretization "NO_TIME", in this case no time is attached to the field, and no
+- \ref MEDCoupling::TypeOfTimeDiscretization "NO_TIME", in this case no time is attached to the field, and no
time-related operation is permitted (for example unable to call
-\ref ParaMEDMEM::MEDCouplingFieldDouble::getValueOn "getValueOn()")
-- \ref ParaMEDMEM::TypeOfTimeDiscretization "ONE_TIME", the field data represent a single time step.
-- \ref ParaMEDMEM::TypeOfTimeDiscretization "LINEAR_TIME", the field data contains \b two arrays, stamped with two
+\ref MEDCoupling::MEDCouplingFieldDouble::getValueOn "getValueOn()")
+- \ref MEDCoupling::TypeOfTimeDiscretization "ONE_TIME", the field data represent a single time step.
+- \ref MEDCoupling::TypeOfTimeDiscretization "LINEAR_TIME", the field data contains \b two arrays, stamped with two
different time points. A linear interpolation of the field values between those two time steps is then possible.
-- \ref ParaMEDMEM::TypeOfTimeDiscretization "CONST_ON_TIME_INTERVAL", the field data contains a single array
+- \ref MEDCoupling::TypeOfTimeDiscretization "CONST_ON_TIME_INTERVAL", the field data contains a single array
of data, but a start- and end-time can be specified, thus declaring that the field represent a constant
set of data during this time interval. All time evaluation function then just check that the given time
fits in the interval.
-Finally, in the code itself, the class \ref ParaMEDMEM::MEDCouplingTimeDiscretization "MEDCouplingTimeDiscretization"
+Finally, in the code itself, the class \ref MEDCoupling::MEDCouplingTimeDiscretization "MEDCouplingTimeDiscretization"
is the concrete representation of this concept.
*/
\page intersec-specifics Specificities of 2D and 3D intersectors
All the options described here can be set using the
-\ref ParaMEDMEM::MEDCouplingRemapper::setOptionInt "MEDCouplingRemapper::setOptionInt",
-\ref ParaMEDMEM::MEDCouplingRemapper::setOptionDouble "MEDCouplingRemapper::setOptionDouble",
-and \ref ParaMEDMEM::MEDCouplingRemapper::setOptionString "MEDCouplingRemapper::setOptionString"
+\ref MEDCoupling::MEDCouplingRemapper::setOptionInt "MEDCouplingRemapper::setOptionInt",
+\ref MEDCoupling::MEDCouplingRemapper::setOptionDouble "MEDCouplingRemapper::setOptionDouble",
+and \ref MEDCoupling::MEDCouplingRemapper::setOptionString "MEDCouplingRemapper::setOptionString"
methods.
\section interpolation2D Special features of 2D intersectors
- the \ref remapper "remapper class" (based on the underlying \ref interpkernel "InterpKernel" library)
for sequential codes, which uses MEDCoupling \ref fields "fields" and other core data structures.
- the \ref parallel "ParaMEDMEM API" for parallel MPI based codes using \c %ParaMEDMEM distributed fields
-(\ref ParaMEDMEM::ParaFIELD "ParaFIELD"), which is also based on the algorithms of the
+(\ref MEDCoupling::ParaFIELD "ParaFIELD"), which is also based on the algorithms of the
\ref interpkernel "InterpKernel" library.
The following space/mesh dimensions are covered:
\section InterpKerHighLevUsage High-level usage
-The simplest way of using the \ref intro-interp "interpolations" in sequential mode is to use the class \c ParaMEDMEM::MEDCouplingRemapper . This class fulfills \c HXX2SALOME rules and may be used in YACS coupling graphs.
+The simplest way of using the \ref intro-interp "interpolations" in sequential mode is to use the class \c MEDCoupling::MEDCouplingRemapper . This class fulfills \c HXX2SALOME rules and may be used in YACS coupling graphs.
-If you intend to use \ref medcoupling "MEDCoupling data structures", the ParaMEDMEM::MEDCouplingRemapper class should be used.
+If you intend to use \ref medcoupling "MEDCoupling data structures", the MEDCoupling::MEDCouplingRemapper class should be used.
\if ENABLE_EXAMPLES
Here is a \ref cpp_mcfield_remapper_highlevel "C++ example".
Each time this parameter appears in API, it will have the semantic
explained here.
The value of the parameter \c meshDimRelToMax is at most in {0,-1,-2,-3}. This relative value specifies a level
-relative to the value returned by ParaMEDMEM::MEDFileMesh::getMeshDimension().
+relative to the value returned by MEDCoupling::MEDFileMesh::getMeshDimension().
A mesh containing MED_TETRA4, MED_TRI3, MED_QUAD4 and MED_POINT1 has a meshDimension
equal to 3. For \c meshDimRelToMax equal to 0 the user will
deal with cells which dimension equals 3-1 that is to say MED_TRI3
and MED_QUAD4.
-An important method is ParaMEDMEM::MEDFileUMesh::getNonEmptyLevels(). It returns all
+An important method is MEDCoupling::MEDFileUMesh::getNonEmptyLevels(). It returns all
non empty levels available. In the previous example, this method will
return {0,-1,-3}. -2 does not appear because no cells with dimension
equal to 1 (3-2) appear in MED file mesh (no MED_SEG2, no MED_SEG3).
nodes.
The parameter of \c meshDimRelToMaxExt appears in
-\ref ParaMEDMEM::MEDFileUMesh "umesh advanced API" of %MEDLoader with the following semantics.
+\ref MEDCoupling::MEDFileUMesh "umesh advanced API" of %MEDLoader with the following semantics.
Some of MED file concepts are available both for cells and
nodes (for example families, groups, numbering) ; that's why for a simpler API this
\subsection AdvMEDLoaderAPIMeshReading Reading a mesh.
-The class that incarnates Read/Write mesh in MED file is ParaMEDMEM::MEDFileUMesh.
+The class that incarnates Read/Write mesh in MED file is MEDCoupling::MEDFileUMesh.
First of all, like basic %MEDLoader API, only MEDfile files whose version >= 2.2 are able
to be read with advanced API.
- Retrieving a family at a specified level :
- Either an array of node/cell id
- \c getFamilyArr method or \c getFamiliesArr
- - Or on \ref ParaMEDMEM::MEDCouplingUMesh "MEDCouplingUMesh" form by calling
+ - Or on \ref MEDCoupling::MEDCouplingUMesh "MEDCouplingUMesh" form by calling
- \c getFamily method or \c getFamilies
- Retrieving a group at a specified level :
- Either an array of node/cell id
- \c getGroupArr method or \c getGroupsArr
- - Or on \ref ParaMEDMEM::MEDCouplingUMesh "MEDCouplingUMesh" form by calling
+ - Or on \ref MEDCoupling::MEDCouplingUMesh "MEDCouplingUMesh" form by calling
- \c getGroup method or \c getGroups
- Retrieving family field array :
\anchor AdvMEDLoaderAPIMeshReadingSampl
\if ENABLE_EXAMPLES
-Here is a \ref cpp_mcumesh_loadfile "C++ example" illustrating a typical use of \ref ParaMEDMEM::MEDCouplingUMesh "MEDCouplingUMesh" instance.
+Here is a \ref cpp_mcumesh_loadfile "C++ example" illustrating a typical use of \ref MEDCoupling::MEDCouplingUMesh "MEDCouplingUMesh" instance.
\endif
\subsection AdvMEDLoaderAPIMeshWriting Writing a mesh.
The use is very symmetric to reading part. It is possible to either
-build a \ref ParaMEDMEM::MEDFileUMesh "MEDFileUMesh" instance from
+build a \ref MEDCoupling::MEDFileUMesh "MEDFileUMesh" instance from
scratch, or to work with an existing instance coming from a loading
from a file.
One important point is that coordinates of a mesh are shared by all
cells whatever their level. That's why the
-\ref ParaMEDMEM::DataArrayDouble "DataArrayDouble" instance
-should be shared by all \ref ParaMEDMEM::MEDCouplingUMesh "MEDCouplingUMesh" used in input parameter of
-set* methods. If the user intends to build a \ref ParaMEDMEM::MEDFileUMesh "MEDFileUMesh" instance from
+\ref MEDCoupling::DataArrayDouble "DataArrayDouble" instance
+should be shared by all \ref MEDCoupling::MEDCouplingUMesh "MEDCouplingUMesh" used in input parameter of
+set* methods. If the user intends to build a \ref MEDCoupling::MEDFileUMesh "MEDFileUMesh" instance from
scratch, a call to \c setCoords should be done first.
Here the list of classes in %MEDLoader advanced API top down sorted :
-- Level 0 : ParaMEDMEM::MEDFileFields
-- Level -1 : ParaMEDMEM::MEDFileFieldMultiTSWithoutSDA
-- Level -2 : ParaMEDMEM::MEDFileField1TSWithoutSDA
-- Level -3 : ParaMEDMEM::MEDFileFieldPerMesh (present only for backward compatibility MED file 2.2)
-- Level -4 : ParaMEDMEM::MEDFileFieldPerMeshPerType
-- Level -5 : ParaMEDMEM::MEDFileFieldPerMeshPerTypePerDisc
+- Level 0 : MEDCoupling::MEDFileFields
+- Level -1 : MEDCoupling::MEDFileFieldMultiTSWithoutSDA
+- Level -2 : MEDCoupling::MEDFileField1TSWithoutSDA
+- Level -3 : MEDCoupling::MEDFileFieldPerMesh (present only for backward compatibility MED file 2.2)
+- Level -4 : MEDCoupling::MEDFileFieldPerMeshPerType
+- Level -5 : MEDCoupling::MEDFileFieldPerMeshPerTypePerDisc
Each level in the tree representing a field (cyan box) is represented by a class. The only difference is that values are grouped in a single big array located
-in level -2 (ParaMEDMEM::MEDFileField1TSWithoutSDA) in which each leaf (level -5) of MED file field
+in level -2 (MEDCoupling::MEDFileField1TSWithoutSDA) in which each leaf (level -5) of MED file field
points to range [\a start, \a end).
As different time steps of a same field and different fields inside a MED file can share or not profiles (yellow box) and localization (red box) a manipulable field classes instance
-(ParaMEDMEM::MEDFileField1TS and ParaMEDMEM::MEDFileFieldMultiTS) in advanced API is the result of a subclass of a data class
-(respectively ParaMEDMEM::MEDFileField1TSWithoutSDA, ParaMEDMEM::MEDFileFieldMultiTSWithoutSDA) and an instance of ParaMEDMEM::MEDFileFieldGlobsReal representing the shared data arrays (SDA)
+(MEDCoupling::MEDFileField1TS and MEDCoupling::MEDFileFieldMultiTS) in advanced API is the result of a subclass of a data class
+(respectively MEDCoupling::MEDFileField1TSWithoutSDA, MEDCoupling::MEDFileFieldMultiTSWithoutSDA) and an instance of MEDCoupling::MEDFileFieldGlobsReal representing the shared data arrays (SDA)
at a specified scope inside the MED file.
\subsection AdvMEDLoaderAPIFieldR Reading a field
\image html med-loader-adv-classes.png "Class diagram of the advanced MEDLoader API"
The blue rectangles show the links to the MEDCoupling objects. Note that in MEDCoupling there is no
-representation of a field of integer. Those are extracted directly as \ref ParaMEDMEM::DataArrayInt "DataArrayInt".
+representation of a field of integer. Those are extracted directly as \ref MEDCoupling::DataArrayInt "DataArrayInt".
-The classes shown on this diagram (all part of the \ref cpp "unfortunately named ParaMEDMEM namespace"):
-- \ref ParaMEDMEM::MEDFileData "MEDFileData", the encapsulation of a complete MED file
+The classes shown on this diagram (all part of the \ref cpp "named MEDCoupling namespace"):
+- \ref MEDCoupling::MEDFileData "MEDFileData", the encapsulation of a complete MED file
and also:
-- \ref ParaMEDMEM::MEDFileMeshes "MEDFileMeshes", the set of meshes in the file
-- \ref ParaMEDMEM::MEDFileMeshMultiTS "MEDFileMeshMultiTS", a single mesh with muliple time steps
-- \ref ParaMEDMEM::MEDFileMesh "MEDFileMesh", a single mesh on a single timestep
-- \ref ParaMEDMEM::MEDFileUMesh "MEDFileUMesh", a single unstructured mesh
+- \ref MEDCoupling::MEDFileMeshes "MEDFileMeshes", the set of meshes in the file
+- \ref MEDCoupling::MEDFileMeshMultiTS "MEDFileMeshMultiTS", a single mesh with muliple time steps
+- \ref MEDCoupling::MEDFileMesh "MEDFileMesh", a single mesh on a single timestep
+- \ref MEDCoupling::MEDFileUMesh "MEDFileUMesh", a single unstructured mesh
and also:
-- \ref ParaMEDMEM::MEDFileFields "MEDFileFields", the set of fields in a MED file
-- \ref ParaMEDMEM::MEDFileAnyTypeFieldMultiTS "MEDFileAnyTypeFieldMultiTS", a single field with multiple
+- \ref MEDCoupling::MEDFileFields "MEDFileFields", the set of fields in a MED file
+- \ref MEDCoupling::MEDFileAnyTypeFieldMultiTS "MEDFileAnyTypeFieldMultiTS", a single field with multiple
time steps (can be an integer field or a double field)
-- \ref ParaMEDMEM::MEDFileFieldMultiTS "MEDFileFieldMultiTS", a single field of doubles with multiple time steps
-- \ref ParaMEDMEM::MEDFileIntFieldMultiTS "MEDFileIntFieldMultiTS", a single field of int with multiple time steps
-- \ref ParaMEDMEM::MEDFileFieldMultiTS "MEDFileAnyTypeField1TS", a single field with a single time step
+- \ref MEDCoupling::MEDFileFieldMultiTS "MEDFileFieldMultiTS", a single field of doubles with multiple time steps
+- \ref MEDCoupling::MEDFileIntFieldMultiTS "MEDFileIntFieldMultiTS", a single field of int with multiple time steps
+- \ref MEDCoupling::MEDFileFieldMultiTS "MEDFileAnyTypeField1TS", a single field with a single time step
(integer or double)
-- \ref ParaMEDMEM::MEDFileField1TS "MEDFileField1TS", a single field of doubles with a single time step
-- \ref ParaMEDMEM::MEDFileIntField1TS "MEDFileIntField1TS", a single field of ints with a single time step
+- \ref MEDCoupling::MEDFileField1TS "MEDFileField1TS", a single field of doubles with a single time step
+- \ref MEDCoupling::MEDFileIntField1TS "MEDFileIntField1TS", a single field of ints with a single time step
and finally:
-- \ref ParaMEDMEM::MEDFileParameters "MEDFileParameters", numerical parameters stored in a MED file
+- \ref MEDCoupling::MEDFileParameters "MEDFileParameters", numerical parameters stored in a MED file
The basic idea of MEDLoader is to exploit as much as possible MED
file capabilities to store MEDCoupling data file in a MED file and
reversely to load from a MED file into a MEDCoupling data structure.
-Basically, the info on components of ParaMEDMEM::DataArrayDouble instances are stored into components and units into MED files. The
+Basically, the info on components of MEDCoupling::DataArrayDouble instances are stored into components and units into MED files. The
name of meshes and fields are used by MEDLoader as is into
-MED file. From a field f with \ref ParaMEDMEM::MEDCouplingTimeDiscretization
+MED file. From a field f with \ref MEDCoupling::MEDCouplingTimeDiscretization
"time discretization" set to ONE_TIME, calls to
\c f->getTime(time,iteration,order) are used by MEDLoader to store the field into MED file. All strings used by MEDLoader should fulfill the rules of MED file where string length
is limited.
\subsection MEDLoaderWriteMesh Writing one mesh in a MED file with MEDLoader
The first think to know is that MEDLoader is using the \b meshName in
-ParaMEDMEM::MEDCouplingMesh instance to put it in MED file.
+MEDCoupling::MEDCouplingMesh instance to put it in MED file.
As explained in previous section \ref MEDLoaderMeshNameConstraint "here",
a mesh in MED file is discriminated by a name, so the \b meshName
It could be interesting to write several meshes in one shot. Two
possibilities:
-- Write several instances of ParaMEDMEM::MEDCouplingUMesh
+- Write several instances of MEDCoupling::MEDCouplingUMesh
lying \b on \b same \b coords \b with \b different \b mesh \b dimensions. In this case MEDLoader::WriteUMeshes is the method you should
use. Typically this method should be used to write files such as
defined \ref MEDLoaderExample2 "here".
This method first checks that all instances share the same
- ParaMEDMEM::DataArrayDouble instance as coords. If not an
+ MEDCoupling::DataArrayDouble instance as coords. If not an
INTERP_KERNEL::Exception will be thrown and an invocation on
- ParaMEDMEM::MEDCouplingPointSet::tryToShareSameCoords will be necessary.
+ MEDCoupling::MEDCouplingPointSet::tryToShareSameCoords will be necessary.
- Write a partition of meshes having \b same \b mesh \b dimension, that is to say a set of
groups and families from given meshes. As in the previous case the
So, basic API is simpler, as shown by method MEDLoader::WriteUMesh that needs no special knowledge about MED file concepts to interact with MED files.
-This API is in the form of a list of public static methods in a class ParaMEDMEM::MEDLoader.
+This API is in the form of a list of public static methods in a class MEDCoupling::MEDLoader.
This simplicity has a cost, the I/O are not (cannot be) optimized.
The n arrays will have only one component and the values contained in these arrays will be ascendently sorted.
-The class that incarnates the described concept is : ParaMEDMEM::MEDCouplingCMesh.
+The class that incarnates the described concept is : MEDCoupling::MEDCouplingCMesh.
\section MEDCouplingCMeshStdBuild Standard building of a cartesian mesh from scratch
This class is also useful for users that want to map the 3D unstructured mesh cell ids level by level along an axis.
-The class that incarnates this concept in MEDCoupling is : \ref ParaMEDMEM::MEDCouplingExtrudedMesh.
+The class that incarnates this concept in MEDCoupling is : \ref MEDCoupling::MEDCouplingExtrudedMesh.
*/
This is a \b non \b instantiable class that implements many algorithm working only on a set of points without any connectivity aspect.
The presence of this class is only for factorization reasons.
-The class that incarnates this concept in \ref medcoupling "MEDCoupling" is : \ref ParaMEDMEM::MEDCouplingPointSet.
-Instantiable class ParaMEDMEM::MEDCouplingUMesh inherits from ParaMEDMEM::MEDCouplingPointSet.
+The class that incarnates this concept in \ref medcoupling "MEDCoupling" is : \ref MEDCoupling::MEDCouplingPointSet.
+Instantiable class MEDCoupling::MEDCouplingUMesh inherits from MEDCoupling::MEDCouplingPointSet.
-Some of most important implemented methods by \ref ParaMEDMEM::MEDCouplingPointSet "MEDCouplingPointSet" class are :
+Some of most important implemented methods by \ref MEDCoupling::MEDCouplingPointSet "MEDCouplingPointSet" class are :
-- \ref ParaMEDMEM::MEDCouplingPointSet::getSpaceDimension "getSpaceDimension"
-- \ref ParaMEDMEM::MEDCouplingPointSet::getNumberOfNodes "getNumberOfNodes"
-- \ref ParaMEDMEM::MEDCouplingPointSet::rotate "rotate"
-- \ref ParaMEDMEM::MEDCouplingPointSet::translate "translate"
-- \ref ParaMEDMEM::MEDCouplingPointSet::scale "scale"
-- \ref ParaMEDMEM::MEDCouplingPointSet::findCommonNodes "findCommonNodes"
-- \ref ParaMEDMEM::MEDCouplingPointSet::renumberNodes "renumberNodes"
-- \ref ParaMEDMEM::MEDCouplingPointSet::getBoundingBox "getBoundingBox"
+- \ref MEDCoupling::MEDCouplingPointSet::getSpaceDimension "getSpaceDimension"
+- \ref MEDCoupling::MEDCouplingPointSet::getNumberOfNodes "getNumberOfNodes"
+- \ref MEDCoupling::MEDCouplingPointSet::rotate "rotate"
+- \ref MEDCoupling::MEDCouplingPointSet::translate "translate"
+- \ref MEDCoupling::MEDCouplingPointSet::scale "scale"
+- \ref MEDCoupling::MEDCouplingPointSet::findCommonNodes "findCommonNodes"
+- \ref MEDCoupling::MEDCouplingPointSet::renumberNodes "renumberNodes"
+- \ref MEDCoupling::MEDCouplingPointSet::getBoundingBox "getBoundingBox"
*/
The norm used for cells connectivity of different types, is the same as specified in MED file except
that connectivities are represented in \b C \b format and \b not \b in \b FORTRAN \b format !
-The class that incarnates the described concept is : ParaMEDMEM::MEDCouplingUMesh.
-\n This class inherits from ParaMEDMEM::MEDCouplingPointSet abstract class.
+The class that incarnates the described concept is : MEDCoupling::MEDCouplingUMesh.
+\n This class inherits from MEDCoupling::MEDCouplingPointSet abstract class.
\n So \ref MEDCouplingUMeshPage "MEDCouplingUMesh" inherits from all \ref MEDCouplingPointSetPage "point set features".
\section MEDCouplingUMeshStdBuild Standard building of an unstructured mesh from scratch
\section MEDCouplingUMeshNodalConnectivity How MEDCouplingUMesh stores its nodal connectivity
-\ref ParaMEDMEM::MEDCouplingUMesh "MEDCouplingUMesh class" stores its nodal connectivity into 2 arrays.
+\ref MEDCoupling::MEDCouplingUMesh "MEDCouplingUMesh class" stores its nodal connectivity into 2 arrays.
-- The first one, the biggest is ParaMEDMEM::MEDCouplingUMesh::_nodal_connectivity.
-- The second one, the less big is ParaMEDMEM::MEDCouplingUMesh::_nodal_connectivity_index.
+- The first one, the biggest is MEDCoupling::MEDCouplingUMesh::_nodal_connectivity.
+- The second one, the less big is MEDCoupling::MEDCouplingUMesh::_nodal_connectivity_index.
\image html MEDCouplingUMeshConn.png "Nodal connectivity storage into MEDCouplingUMesh class"
\image latex MEDCouplingUMeshConn.eps "Nodal connectivity storage into MEDCouplingUMesh class"
\section MEDCouplingUMeshAdvBuild Advanced building of an unstructured mesh from scratch
-Here we are going to build the mesh in a more advanced manner. This method expects that the user knows the storage format underlying ParaMEDMEM::MEDCouplingUMesh.
+Here we are going to build the mesh in a more advanced manner. This method expects that the user knows the storage format underlying MEDCoupling::MEDCouplingUMesh.
The same mesh than \ref MEDCouplingUMeshStdBuild "in the standard section above" is going to be implemented using advanced method.
to 2, can have \b cells of type NORM_TRI3 (triangles) and NORM_POLYGON (arbitrary 2D polygons) for example.
It can still have a space dimension of 3, meaning that we describe a planar surface embedded in a 3D space.
-The (abstract) class that covers the concept described above is \ref ParaMEDMEM::MEDCouplingMesh.
+The (abstract) class that covers the concept described above is \ref MEDCoupling::MEDCouplingMesh.
<h1>Available (non abstract) mesh types in MEDCoupling</h1>
- \ref medcoupling "MEDCoupling" that describes data structures used for cross process exchange of \ref meshes "meshes" and \ref fields "fields".
- \ref medloader "MEDLoader" and ParaMEDLoader that provides I/O functions to the MED file format with sequential and parallel processing, respectively. Those are built on top of the MED-file library.
- \ref intro-interp "interpolation tools" that provides mathematical structures and algorithms for interpolation and
- localization. It is implemented in three blocks: \ref INTERP_KERNEL "InterpKernel", \ref ParaMEDMEM::MEDCouplingRemapper "Remapper" and \ref parallel "ParaMEDMEM" (Remapper with parallel processing).
+ localization. It is implemented in three blocks: \ref INTERP_KERNEL "InterpKernel", \ref MEDCoupling::MEDCouplingRemapper "Remapper" and \ref parallel "ParaMEDMEM" (Remapper with parallel processing).
*/
The following intuitive rules have been used to map the C++ objects to the Python ones:
- std::vector become standard Python lists, see for example \ref py_mcdataarrayint_setpartofvalues where the function
-ParaMEDMEM::DataArray::setInfoOnComponents() is used.
+MEDCoupling::DataArray::setInfoOnComponents() is used.
- the return values of C++ functions (usually passed as last arguments in the C++ prototype) are
-returned directly as a tuple, see for example the Python usage of ParaMEDMEM::MEDCouplingUMesh::getReverseNodalConnectivity() in \ref cpp_mcumesh_getReverseNodalConnectivity. The
+returned directly as a tuple, see for example the Python usage of MEDCoupling::MEDCouplingUMesh::getReverseNodalConnectivity() in \ref cpp_mcumesh_getReverseNodalConnectivity. The
initial prototype where the return values are passed as argument can however still be used, provided you instantiate
the returned objects first.
- the indexing mechanism is greatly simplified in Python, and offers similar functionalities to what NumPy
# MEDCoupling classes to include
#
SET(_classes_MEDCoupling
- ParaMEDMEM_1_1MEDCouplingPointSet
- ParaMEDMEM_1_1MEDCouplingUMesh
- ParaMEDMEM_1_1MEDCouplingCMesh
- ParaMEDMEM_1_1MEDCouplingRemapper
- ParaMEDMEM_1_1DataArray
- ParaMEDMEM_1_1DataArrayInt
- ParaMEDMEM_1_1DataArrayDouble
+ MEDCoupling_1_1MEDCouplingPointSet
+ MEDCoupling_1_1MEDCouplingUMesh
+ MEDCoupling_1_1MEDCouplingCMesh
+ MEDCoupling_1_1MEDCouplingRemapper
+ MEDCoupling_1_1DataArray
+ MEDCoupling_1_1DataArrayInt
+ MEDCoupling_1_1DataArrayDouble
)
#
#
SET(_classes_MEDLoader
MEDLoader
- ParaMEDMEM_1_1MEDFileMeshes
- ParaMEDMEM_1_1MEDFileMesh
- ParaMEDMEM_1_1MEDFileUMesh
- ParaMEDMEM_1_1MEDFileCMesh
+ MEDCoupling_1_1MEDFileMeshes
+ MEDCoupling_1_1MEDFileMesh
+ MEDCoupling_1_1MEDFileUMesh
+ MEDCoupling_1_1MEDFileCMesh
)
##
// generation of documentation for inline methods.
-namespace ParaMEDMEM
+namespace MEDCoupling
{
/*!
* Checks if \a this field is correctly defined, else an exception is thrown.
void MEDCouplingField::checkCoherency() const throw(INTERP_KERNEL::Exception) {}
/*!
* Returns the underlying mesh of \a this field.
- * \return const ParaMEDMEM::MEDCouplingMesh * - a const pointer to the underlying mesh.
+ * \return const MEDCoupling::MEDCouplingMesh * - a const pointer to the underlying mesh.
*/
- const ParaMEDMEM::MEDCouplingMesh *MEDCouplingField::getMesh() const {}
+ const MEDCoupling::MEDCouplingMesh *MEDCouplingField::getMesh() const {}
/*!
* Returns the description of \a this field.
* \return const char * - a string containing the field description.
// * groupping methods into "Basic API", "Advanced" and "Others..." sections
-namespace ParaMEDMEM
+namespace MEDCoupling
{
/*!
* Returns a new MEDCouplingFieldDouble containing sum values of corresponding values of
double MEDCouplingFieldDouble::getIJ(int tupleId, int compoId) const {}
}
-namespace ParaMEDMEM
+namespace MEDCoupling
{
/*! \name Basic API */
///@{
// * groupping methods into "Basic API", "Advanced" and "Others..." sections
-namespace ParaMEDMEM
+namespace MEDCoupling
{
/*!
* Returns the attribute \a _name of \a this array.
}
-namespace ParaMEDMEM
+namespace MEDCoupling
{
//================================================================================
/////////////////////// DataArray GROUPPING //////////////////////////////////////
// * groupping methods into "Basic API", "Advanced" and "Others..." sections
-namespace ParaMEDMEM
+namespace MEDCoupling
{
//================================================================================
/*!
void MEDCouplingMesh::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,DataArrayInt *&cellCor) const throw(INTERP_KERNEL::Exception) {}
}
-namespace ParaMEDMEM
+namespace MEDCoupling
{
//================================================================================
/////////////////////// GROUPPING members of MEDCouplingMesh /////////////////////
// This file contains some code used only for
// * generation of documentation for inline methods of MEDCouplingPointSet
-namespace ParaMEDMEM
+namespace MEDCoupling
{
/*!
// * generation of documentation for inline methods of MEDCouplingUMesh class,
// * groupping methods into "Basic API", "Advanced" and "Others..." sections
-namespace ParaMEDMEM
+namespace MEDCoupling
{
/*!
* Returns the nodal connectivity array. For more info on how data in stored in
DataArrayInt * MEDCouplingUMesh::getNodalConnectivityIndex() {}
}
-namespace ParaMEDMEM
+namespace MEDCoupling
{
//================================================================================
/////////////////////// MEDCouplingUMesh GROUPPING ///////////////////////////////
// generation of documentation for inline methods.
-namespace ParaMEDMEM // inline methods of MEDFileField1TSWithoutSDA
+namespace MEDCoupling // inline methods of MEDFileField1TSWithoutSDA
{
/*!
* Returns the number of iteration where \a this field has been calculated.
// const std::string& MEDFileField1TSWithoutSDA::getDtUnit() const {}
}
-namespace ParaMEDMEM // inline methods of MEDFileFieldGlobsReal
+namespace MEDCoupling // inline methods of MEDFileFieldGlobsReal
{
/*!
* Returns non empty names of all used profiles. To get all profiles call getPfls().
// * groupping methods into "Basic API", "Advanced" and "Others..." sections
-namespace ParaMEDMEM
+namespace MEDCoupling
{
/*!
* Sets the name of \a this mesh.
}
-namespace ParaMEDMEM
+namespace MEDCoupling
{
/*! \name Basic API */
///@{
*/
/*!
- * \namespace ParaMEDMEM
+ * \namespace MEDCoupling
* \brief Namespace gathering the core MEDCoupling functionalities, the advanced MEDLoader classes and the parallel classes.
*/
import os
#rep=("namespace ParaMEDMEM","namespace MEDCoupling")
-#rep=("ParaMEDMEM::","MEDCoupling::")
+rep=("ParaMEDMEM::","MEDCoupling::")
#rep=("ParaMEDMEMImpl::","MEDCouplingImpl::")
#rep=("_ParaMEDMEM__","_MEDCoupling__")
#rep=("ParaMEDMEM_","MEDCoupling_")
#rep=("ParaMEDMEMData","MEDCouplingData")
-dirs=["MEDCoupling","MEDCoupling/Test","MEDLoader","MEDLoader/Swig","MEDLoader/Test","MEDPartitioner","MEDPartitioner/Test","MEDPartitioner_Swig","RENUMBER","RENUMBER_Swig","INTERP_KERNELTest","ParaMEDMEM","ParaMEDLoader","ParaMEDMEMTest","ParaMEDMEM_Swig"]
-dirname=dirs[-1]
-i=0
-for fi in os.listdir(dirname):
- fi2=os.path.join(dirname,fi)
- if not os.path.isfile(fi2):
- continue
- f=file(fi2) ; lines=f.readlines() ; del f
+
+#rep=("ParaMEDMEM_1","MEDCoupling_1")
+
+def rep0(fi,rep):
+ f=file(fi) ; lines=f.readlines() ; del f
lines2=[line.replace(*rep) for line in lines]
if lines2!=lines:
- i+=1
- f=file(fi2,"w") ; f.writelines(lines2) ; f.flush()
- pass
+ f=file(fi,"w") ; f.writelines(lines2) ; f.flush()
+ return 1
+ else:
+ return 0
+
+def rep1(dirname,rep):
+ i=0
+ for fi in os.listdir(dirname):
+ fi2=os.path.join(dirname,fi)
+ if not os.path.isfile(fi2):
+ continue
+ i+=rep0(fi2,rep)
+ return i
+
+dirs=["MEDCoupling","MEDCoupling/Test","MEDLoader","MEDLoader/Swig","MEDLoader/Test","MEDPartitioner","MEDPartitioner/Test","MEDPartitioner_Swig","RENUMBER","RENUMBER_Swig","INTERP_KERNELTest","ParaMEDMEM","ParaMEDLoader","ParaMEDMEMTest","ParaMEDMEM_Swig","doc/user/doxygen/fakesources","doc/user/doxygen/doxy2swig","doc/user/doxygen/doxfiles"]
+dirname=dirs[-1]
+i=0
+
+for r,dirs,fis in os.walk(dirname):
+ for fi in fis:
+ if os.path.splitext(fi)[1] not in [".dox",".doxy"]:
+ continue
+ i+=rep0(os.path.join(r,fi),rep)
print i
