medcoupling 9.13.0__cp311-cp311-win_amd64.whl → 9.15.0__cp311-cp311-win_amd64.whl

MEDLoaderSplitter.py

@@ -1,5 +1,5 @@
 #  -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2024  CEA, EDF
+# Copyright (C) 2007-2025  CEA, EDF
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -22,178 +22,219 @@
 from medcoupling import *
 import os
 
+
 class MEDLoaderSplitter:
     @classmethod
-    def New(cls,mfd,idsLst):
-        """ mfd is a MEDFileData instance containing only one mesh. idsLst is a list of DataArrayInt containing each the ids per processor """
-        return MEDLoaderSplitter(mfd,idsLst)
+    def New(cls, mfd, idsLst):
+        """mfd is a MEDFileData instance containing only one mesh. idsLst is a list of DataArrayInt containing each the ids per processor"""
+        return MEDLoaderSplitter(mfd, idsLst)
         pass
 
-    def __init__(self,mfd,idsLst):
-        """ mfd is a MEDFileData instance containing only one mesh. idsLst is a list of DataArrayInt containing each the ids per processor """
-        mfmsh=mfd.getMeshes()
-        mfflds=mfd.getFields()
-        if len(mfmsh)!=1:
+    def __init__(self, mfd, idsLst):
+        """mfd is a MEDFileData instance containing only one mesh. idsLst is a list of DataArrayInt containing each the ids per processor"""
+        mfmsh = mfd.getMeshes()
+        mfflds = mfd.getFields()
+        if len(mfmsh) != 1:
             raise InterpKernelException("Works only with one mesh !")
-        mfflds=mfflds.partOfThisLyingOnSpecifiedMeshName(mfmsh[0].getName())
-        retm=self.__splitMesh(mfmsh[0],idsLst)
-        retf=self.__splitFields(mfmsh[0],retm,mfflds,idsLst)
-        self._mfd_splitted=[MEDFileData() for i in range(len(idsLst))]
-        for a,b,c in zip(self._mfd_splitted,retf,retm):
-            a.setFields(b) ; a.setMeshes(c)
+        mfflds = mfflds.partOfThisLyingOnSpecifiedMeshName(mfmsh[0].getName())
+        retm = self.__splitMesh(mfmsh[0], idsLst)
+        retf = self.__splitFields(mfmsh[0], retm, mfflds, idsLst)
+        self._mfd_splitted = [MEDFileData() for i in range(len(idsLst))]
+        for a, b, c in zip(self._mfd_splitted, retf, retm):
+            a.setFields(b)
+            a.setMeshes(c)
             pass
         pass
 
     def getSplittedInstances(self):
         return self._mfd_splitted
-    
+
     @classmethod
-    def __splitMEDFileField1TSNodePfl(cls,mm,fieldName,pfl,ids,cache,procID):
+    def __splitMEDFileField1TSNodePfl(cls, mm, fieldName, pfl, ids, cache, procID):
         zeLev = None
         for lev in reversed(mm.getNonEmptyLevels()):
-            cellIds = mm[lev].getCellIdsLyingOnNodes(pfl,True)
-            if mm[lev][cellIds].computeFetchedNodeIds().isEqualWithoutConsideringStr(pfl):
+            cellIds = mm[lev].getCellIdsLyingOnNodes(pfl, True)
+            if (
+                mm[lev][cellIds]
+                .computeFetchedNodeIds()
+                .isEqualWithoutConsideringStr(pfl)
+            ):
                 zeLev = lev
                 break
-        assert(zeLev is not None)
-        cache[(fieldName,procID)]["zeLev"]=zeLev
+        assert zeLev is not None
+        cache[(fieldName, procID)]["zeLev"] = zeLev
         #
-        m0Part=mm[0][ids]
-        mLev=mm[zeLev]
+        m0Part = mm[0][ids]
+        mLev = mm[zeLev]
         #
-        trado2n=m0Part.zipCoordsTraducer() # 3D part of nodes o2n
-        trad=trado2n.invertArrayO2N2N2O(m0Part.getNumberOfNodes()) # 3D part of nodes n2o
-        part=mLev.getCellIdsFullyIncludedInNodeIds(trad)
-        mSubPart=mLev[part] # 2D part lying on 3D part
-        mSubPartReducedNode=mSubPart.deepCopy() ; mSubPartReducedNode.renumberNodesInConn(trado2n) ; mSubPartReducedNode.setCoords(m0Part.getCoords()) # 2D part lying on 3D part node zipped 
+        trado2n = m0Part.zipCoordsTraducer()  # 3D part of nodes o2n
+        trad = trado2n.invertArrayO2N2N2O(
+            m0Part.getNumberOfNodes()
+        )  # 3D part of nodes n2o
+        part = mLev.getCellIdsFullyIncludedInNodeIds(trad)
+        mSubPart = mLev[part]  # 2D part lying on 3D part
+        mSubPartReducedNode = mSubPart.deepCopy()
+        mSubPartReducedNode.renumberNodesInConn(trado2n)
+        mSubPartReducedNode.setCoords(
+            m0Part.getCoords()
+        )  # 2D part lying on 3D part node zipped
         #
-        if mSubPart.getNumberOfCells()==0:
-            cache[(fieldName,procID)]["res"] = None
-            cache[(fieldName,procID)]["subProfileInProcReducedNode"] = None
+        if mSubPart.getNumberOfCells() == 0:
+            cache[(fieldName, procID)]["res"] = None
+            cache[(fieldName, procID)]["subProfileInProcReducedNode"] = None
             return
         cellsInSubPartFetchedByProfile = mSubPart.getCellIdsFullyIncludedInNodeIds(pfl)
-        mSubPartFetchedByPfl=mSubPart[cellsInSubPartFetchedByProfile]
-        subProfileInProc=mSubPartFetchedByPfl.computeFetchedNodeIds()
+        mSubPartFetchedByPfl = mSubPart[cellsInSubPartFetchedByProfile]
+        subProfileInProc = mSubPartFetchedByPfl.computeFetchedNodeIds()
         mSubPartFetchedByPfl.zipCoords()
         #
-        res=pfl.findIdForEach(subProfileInProc)
-        subProfileInProcReducedNode=subProfileInProc.deepCopy() ; subProfileInProcReducedNode.transformWithIndArr(trado2n)
+        res = pfl.findIdForEach(subProfileInProc)
+        subProfileInProcReducedNode = subProfileInProc.deepCopy()
+        subProfileInProcReducedNode.transformWithIndArr(trado2n)
         subProfileInProcReducedNode.setName(pfl.getName())
         #
-        cache[(fieldName,procID)]["res"] = res
-        cache[(fieldName,procID)]["subProfileInProcReducedNode"] = subProfileInProcReducedNode
+        cache[(fieldName, procID)]["res"] = res
+        cache[(fieldName, procID)]["subProfileInProcReducedNode"] = (
+            subProfileInProcReducedNode
+        )
         pass
 
-    
     @classmethod
-    def __splitMEDFileField1TSNode(cls,t,mm,mmOut,f1tsIn,f1tsOut,ids,cache,procID):
-        if len(f1tsIn.getPflsReallyUsed())!=0:
-            arr,pfl=f1tsIn.getFieldWithProfile(ON_NODES,0,mm)
+    def __splitMEDFileField1TSNode(
+        cls, t, mm, mmOut, f1tsIn, f1tsOut, ids, cache, procID
+    ):
+        if len(f1tsIn.getPflsReallyUsed()) != 0:
+            arr, pfl = f1tsIn.getFieldWithProfile(ON_NODES, 0, mm)
             #
-            if (f1tsIn.getName(),procID) not in cache:
-                cls.__splitMEDFileField1TSNodePfl(mm,f1tsIn.getName(),pfl,ids,cache,procID)
+            if (f1tsIn.getName(), procID) not in cache:
+                cls.__splitMEDFileField1TSNodePfl(
+                    mm, f1tsIn.getName(), pfl, ids, cache, procID
+                )
                 pass
-            zeLev = cache[(f1tsIn.getName(),procID)]["zeLev"]
-            res = cache[(f1tsIn.getName(),procID)]["res"]
-            subProfileInProcReducedNode = cache[(f1tsIn.getName(),procID)]["subProfileInProcReducedNode"]
-            if (zeLev is None) or (res is None) or (subProfileInProcReducedNode is None):
+            zeLev = cache[(f1tsIn.getName(), procID)]["zeLev"]
+            res = cache[(f1tsIn.getName(), procID)]["res"]
+            subProfileInProcReducedNode = cache[(f1tsIn.getName(), procID)][
+                "subProfileInProcReducedNode"
+            ]
+            if (
+                (zeLev is None)
+                or (res is None)
+                or (subProfileInProcReducedNode is None)
+            ):
                 return
-            if len(res)>0:
-                fRes=MEDCouplingFieldDouble(ON_NODES)
+            if len(res) > 0:
+                fRes = MEDCouplingFieldDouble(ON_NODES)
                 fRes.setArray(arr[res])
                 fRes.setName(f1tsIn.getName())
-                #fRes.setMesh(mSubPartFetchedByPfl)
-                #fRes.copyAllTinyAttrFrom(f_medcoupling)
-                a,b,c=f1tsIn.getTime(); fRes.setTime(c,a,b)
-                f1tsOut.setFieldProfile(fRes,mmOut,zeLev,subProfileInProcReducedNode)
+                # fRes.setMesh(mSubPartFetchedByPfl)
+                # fRes.copyAllTinyAttrFrom(f_medcoupling)
+                a, b, c = f1tsIn.getTime()
+                fRes.setTime(c, a, b)
+                f1tsOut.setFieldProfile(fRes, mmOut, zeLev, subProfileInProcReducedNode)
                 pass
-            #raise RuntimeError("Field \"%s\" contains profiles ! Not supported yet ! This field will be ignored !" % (f1tsIn.getName()))
+            # raise RuntimeError("Field \"%s\" contains profiles ! Not supported yet ! This field will be ignored !" % (f1tsIn.getName()))
         else:
-            f=f1tsIn.getFieldOnMeshAtLevel(t,0,mm)
-            fRet=f[ids]
+            f = f1tsIn.getFieldOnMeshAtLevel(t, 0, mm)
+            fRet = f[ids]
             f1tsOut.setFieldNoProfileSBT(fRet)
             pass
         pass
-    
+
     @classmethod
-    def __splitMEDFileField1TSCell(cls,t,mm,mmOut,f1tsIn,f1tsOut,ids,cache,procID):
-        f=f1tsIn.getFieldOnMeshAtLevel(t,0,mm)
-        fRet=f[ids]
-        m=fRet.getMesh() ; m.zipCoords()
-        o2n=m.getRenumArrForMEDFileFrmt() ; fRet.renumberCells(o2n,False)
+    def __splitMEDFileField1TSCell(
+        cls, t, mm, mmOut, f1tsIn, f1tsOut, ids, cache, procID
+    ):
+        f = f1tsIn.getFieldOnMeshAtLevel(t, 0, mm)
+        fRet = f[ids]
+        m = fRet.getMesh()
+        m.zipCoords()
+        o2n = m.getRenumArrForMEDFileFrmt()
+        fRet.renumberCells(o2n, False)
         f1tsOut.setFieldNoProfileSBT(fRet)
         pass
-    
-    def __splitMEDFileField1TS(self,mm,mmOutList,f1ts,idsLst,cache):
+
+    def __splitMEDFileField1TS(self, mm, mmOutList, f1ts, idsLst, cache):
         """
-           Split input f1ts into parts defined by idsLst.
+        Split input f1ts into parts defined by idsLst.
 
-           :param mm: The underlying mesh of f1ts
-           :param f1ts: The field to be split
-           :param idsLst: For each proc the cell ids at level 0
-           :return: A list of fields.
+        :param mm: The underlying mesh of f1ts
+        :param f1ts: The field to be split
+        :param idsLst: For each proc the cell ids at level 0
+        :return: A list of fields.
         """
-        ret=[f1ts.__class__() for i in range(len(idsLst))]
-        dico={ON_CELLS:MEDLoaderSplitter.__splitMEDFileField1TSCell,
-              ON_NODES:MEDLoaderSplitter.__splitMEDFileField1TSNode,
-              ON_GAUSS_PT:MEDLoaderSplitter.__splitMEDFileField1TSCell,
-              ON_GAUSS_NE:MEDLoaderSplitter.__splitMEDFileField1TSCell}
+        ret = [f1ts.__class__() for i in range(len(idsLst))]
+        dico = {
+            ON_CELLS: MEDLoaderSplitter.__splitMEDFileField1TSCell,
+            ON_NODES: MEDLoaderSplitter.__splitMEDFileField1TSNode,
+            ON_GAUSS_PT: MEDLoaderSplitter.__splitMEDFileField1TSCell,
+            ON_GAUSS_NE: MEDLoaderSplitter.__splitMEDFileField1TSCell,
+        }
         for t in f1ts.getTypesOfFieldAvailable():
-            for procID,f0 in enumerate(ret):
-                dico[t](t,mm,mmOutList[procID][0],f1ts,f0,idsLst[procID],cache,procID)
+            for procID, f0 in enumerate(ret):
+                dico[t](
+                    t, mm, mmOutList[procID][0], f1ts, f0, idsLst[procID], cache, procID
+                )
                 pass
             pass
         return ret
-    
-    def __splitFields(self,mm,mmOutList,mfflds,idsLst):
+
+    def __splitFields(self, mm, mmOutList, mfflds, idsLst):
         ret0 = [MEDFileFields() for i in range(len(idsLst))]
         from collections import defaultdict
+
         cache = defaultdict(dict)
         for fmts in mfflds:
-            ret1=[fmts.__class__() for i in range(len(idsLst))]
+            ret1 = [fmts.__class__() for i in range(len(idsLst))]
             for f1ts in fmts:
-                for fmtsPart,f1tsPart in zip(ret1,self.__splitMEDFileField1TS(mm,mmOutList,f1ts,idsLst,cache)):
+                for fmtsPart, f1tsPart in zip(
+                    ret1,
+                    self.__splitMEDFileField1TS(mm, mmOutList, f1ts, idsLst, cache),
+                ):
                     if f1tsPart.getUndergroundDataArray():
-                        if len(f1tsPart.getUndergroundDataArray())!=0 :
+                        if len(f1tsPart.getUndergroundDataArray()) != 0:
                             fmtsPart.pushBackTimeStep(f1tsPart)
                     pass
                 pass
-            for fieldsPart,fmtsPart in zip(ret0,ret1):
-                if len(fmtsPart) != 0 :
-                    fieldsPart.pushField(fmtsPart);
+            for fieldsPart, fmtsPart in zip(ret0, ret1):
+                if len(fmtsPart) != 0:
+                    fieldsPart.pushField(fmtsPart)
                 pass
             pass
         return ret0
 
-    def __splitMesh(self,mfm,idsLst):
+    def __splitMesh(self, mfm, idsLst):
         ret0 = [MEDFileMeshes() for i in range(len(idsLst))]
-        m=mfm[0]
-        addlevs=list(mfm.getNonEmptyLevels())[1:]
-        dAddlevs={k:mfm[k] for k in addlevs}
-        for ret,ids in zip(ret0,idsLst):
-            mlPart=mfm.createNewEmpty()
-            mPart=m[ids] ; trado2n=mPart.zipCoordsTraducer()
-            trad=trado2n.invertArrayO2N2N2O(mPart.getNumberOfNodes())
-            mlPart[0]=mPart
+        m = mfm[0]
+        addlevs = list(mfm.getNonEmptyLevels())[1:]
+        dAddlevs = {k: mfm[k] for k in addlevs}
+        for ret, ids in zip(ret0, idsLst):
+            mlPart = mfm.createNewEmpty()
+            mPart = m[ids]
+            trado2n = mPart.zipCoordsTraducer()
+            trad = trado2n.invertArrayO2N2N2O(mPart.getNumberOfNodes())
+            mlPart[0] = mPart
             if 0 in mfm.getFamArrNonEmptyLevelsExt():
-                mlPart.setFamilyFieldArr(0,mfm.getFamilyFieldAtLevel(0)[ids])
+                mlPart.setFamilyFieldArr(0, mfm.getFamilyFieldAtLevel(0)[ids])
                 pass
             if 0 in mfm.getNameArrNonEmptyLevelsExt():
                 mlPart.setNameFieldAtLevel(0, mfm.getNameFieldAtLevel(0)[ids])
             if 1 in mfm.getFamArrNonEmptyLevelsExt():
-                mlPart.setFamilyFieldArr(1,mfm.getFamilyFieldAtLevel(1)[trad])
+                mlPart.setFamilyFieldArr(1, mfm.getFamilyFieldAtLevel(1)[trad])
                 pass
             if 1 in mfm.getNameArrNonEmptyLevelsExt():
                 mlPart.setNameFieldAtLevel(1, mfm.getNameFieldAtLevel(1)[trad])
-            for k,v in dAddlevs.items():
-                part=v.getCellIdsFullyIncludedInNodeIds(trad)
-                mSubPart=v[part] ; mSubPart.renumberNodesInConn(trado2n) ; mSubPart.setCoords(mPart.getCoords())
-                mlPart[k]=mSubPart
-                mlPart.setFamilyFieldArr(k,mfm.getFamilyFieldAtLevel(k)[part])
+            for k, v in dAddlevs.items():
+                part = v.getCellIdsFullyIncludedInNodeIds(trad)
+                mSubPart = v[part]
+                mSubPart.renumberNodesInConn(trado2n)
+                mSubPart.setCoords(mPart.getCoords())
+                mlPart[k] = mSubPart
+                mlPart.setFamilyFieldArr(k, mfm.getFamilyFieldAtLevel(k)[part])
                 if k in mfm.getNameArrNonEmptyLevelsExt():
                     mlPart.setNameFieldAtLevel(k, mfm.getNameFieldAtLevel(k)[part])
             mlPart.copyFamGrpMapsFrom(mfm)
             ret.pushMesh(mlPart)
             pass
         return ret0
+
     pass

MEDRenumber.py

@@ -1625,6 +1625,21 @@ class DataArrayFloat(DataArray):
         """
         return _MEDRenumber.DataArrayFloat_Meld(a1, a2)
 
+    @staticmethod
+    def LoadForDbg(fileName):
+        r"""
+        LoadForDbg(std::string const & fileName) -> MCAuto< MEDCoupling::DataArrayFloat >
+        1
+        """
+        return _MEDRenumber.DataArrayFloat_LoadForDbg(fileName)
+
+    def writeForDbg(self, fileName):
+        r"""
+        writeForDbg(DataArrayFloat self, std::string const & fileName)
+        1
+        """
+        return _MEDRenumber.DataArrayFloat_writeForDbg(self, fileName)
+
     @staticmethod
     def New(*args):
         r"""
@@ -2036,6 +2051,13 @@ class DataArrayDouble(DataArray):
         """
         return _MEDRenumber.DataArrayDouble_duplicateEachTupleNTimes(self, nbTimes)
 
+    def duplicateNTimes(self, nbTimes):
+        r"""
+        duplicateNTimes(DataArrayDouble self, mcIdType nbTimes) -> MCAuto< MEDCoupling::DataArrayDouble >
+        1
+        """
+        return _MEDRenumber.DataArrayDouble_duplicateNTimes(self, nbTimes)
+
     def getDifferentValues(self, prec, limitTupleId=-1):
         r"""
         getDifferentValues(DataArrayDouble self, double prec, int limitTupleId=-1) -> DataArrayDouble
@@ -2636,6 +2658,21 @@ class DataArrayDouble(DataArray):
         """
         return _MEDRenumber.DataArrayDouble_convertToFloatArr(self)
 
+    @staticmethod
+    def LoadForDbg(fileName):
+        r"""
+        LoadForDbg(std::string const & fileName) -> MCAuto< MEDCoupling::DataArrayDouble >
+        1
+        """
+        return _MEDRenumber.DataArrayDouble_LoadForDbg(fileName)
+
+    def writeForDbg(self, fileName):
+        r"""
+        writeForDbg(DataArrayDouble self, std::string const & fileName)
+        1
+        """
+        return _MEDRenumber.DataArrayDouble_writeForDbg(self, fileName)
+
     @staticmethod
     def New(*args):
         r"""
@@ -3529,6 +3566,14 @@ class DataArrayByte(DataArrayChar):
         """
         return _MEDRenumber.DataArrayByte_byteValue(self)
 
+    @staticmethod
+    def LoadForDbg(fileName):
+        r"""
+        LoadForDbg(std::string const & fileName) -> MCAuto< MEDCoupling::DataArrayByte >
+        1
+        """
+        return _MEDRenumber.DataArrayByte_LoadForDbg(fileName)
+
     @staticmethod
     def New(*args):
         r"""
@@ -4493,6 +4538,13 @@ class DataArrayInt32(DataArray):
         """
         return _MEDRenumber.DataArrayInt32_abs(self)
 
+    def sortPerTuple(self, asc):
+        r"""
+        sortPerTuple(DataArrayInt32 self, bool asc)
+        1
+        """
+        return _MEDRenumber.DataArrayInt32_sortPerTuple(self, asc)
+
     def computeAbs(self):
         r"""
         computeAbs(DataArrayInt32 self) -> DataArrayInt32
@@ -4720,6 +4772,13 @@ class DataArrayInt32(DataArray):
         """
         return _MEDRenumber.DataArrayInt32_duplicateEachTupleNTimes(self, nbTimes)
 
+    def duplicateNTimes(self, nbTimes):
+        r"""
+        duplicateNTimes(DataArrayInt32 self, mcIdType nbTimes) -> MCAuto< MEDCoupling::DataArrayInt32 >
+        1
+        """
+        return _MEDRenumber.DataArrayInt32_duplicateNTimes(self, nbTimes)
+
     def getDifferentValues(self):
         r"""
         getDifferentValues(DataArrayInt32 self) -> DataArrayInt32
@@ -4817,6 +4876,21 @@ class DataArrayInt32(DataArray):
         """
         return _MEDRenumber.DataArrayInt32_powEqual(self, other)
 
+    @staticmethod
+    def LoadForDbg(fileName):
+        r"""
+        LoadForDbg(std::string const & fileName) -> MCAuto< MEDCoupling::DataArrayInt32 >
+        1
+        """
+        return _MEDRenumber.DataArrayInt32_LoadForDbg(fileName)
+
+    def writeForDbg(self, fileName):
+        r"""
+        writeForDbg(DataArrayInt32 self, std::string const & fileName)
+        1
+        """
+        return _MEDRenumber.DataArrayInt32_writeForDbg(self, fileName)
+
     def fromLinkedListOfPairToList(self):
         r"""
         fromLinkedListOfPairToList(DataArrayInt32 self) -> MCAuto< MEDCoupling::DataArrayInt32 >
@@ -5368,6 +5442,20 @@ class DataArrayInt32(DataArray):
         """
         return _MEDRenumber.DataArrayInt32_findIdsRangesInListOfIds(self, listOfIds)
 
+    def forThisAsPartitionBuildReduction(self, commonEntities, commonEntitiesIndex):
+        r"""
+        forThisAsPartitionBuildReduction(DataArrayInt32 self, DataArrayInt32 commonEntities, DataArrayInt32 commonEntitiesIndex) -> PyObject *
+        1
+        """
+        return _MEDRenumber.DataArrayInt32_forThisAsPartitionBuildReduction(self, commonEntities, commonEntitiesIndex)
+
+    def fromListOfPairsToIndexArray(self):
+        r"""
+        fromListOfPairsToIndexArray(DataArrayInt32 self) -> PyObject *
+        1
+        """
+        return _MEDRenumber.DataArrayInt32_fromListOfPairsToIndexArray(self)
+
     def isRange(self):
         r"""
         isRange(DataArrayInt32 self) -> PyObject *
@@ -5383,6 +5471,13 @@ class DataArrayInt32(DataArray):
         """
         return _MEDRenumber.DataArrayInt32_RemoveIdsFromIndexedArrays(li, arr, arrIndx, offsetForRemoval)
 
+    def findCommonTuples(self, limitNodeId=-1):
+        r"""
+        findCommonTuples(DataArrayInt32 self, mcIdType limitNodeId=-1) -> PyObject
+        1
+        """
+        return _MEDRenumber.DataArrayInt32_findCommonTuples(self, limitNodeId)
+
     @staticmethod
     def ExtractFromIndexedArrays(li, arrIn, arrIndxIn):
         r"""
@@ -5408,6 +5503,30 @@ class DataArrayInt32(DataArray):
         """
         return _MEDRenumber.DataArrayInt32_SetPartOfIndexedArrays(li, arrIn, arrIndxIn, srcArr, srcArrIndex)
 
+    @staticmethod
+    def FromVTKInternalReprOfPolyedra(arrIn, arrIndxIn):
+        r"""
+        FromVTKInternalReprOfPolyedra(DataArrayInt32 arrIn, DataArrayInt32 arrIndxIn) -> PyObject *
+        1
+        """
+        return _MEDRenumber.DataArrayInt32_FromVTKInternalReprOfPolyedra(arrIn, arrIndxIn)
+
+    @staticmethod
+    def FromVTK94InternalReprOfPolyedra(arrIn, arrIndxIn, arrIndxIn2):
+        r"""
+        FromVTK94InternalReprOfPolyedra(DataArrayInt32 arrIn, DataArrayInt32 arrIndxIn, DataArrayInt32 arrIndxIn2) -> PyObject *
+        1
+        """
+        return _MEDRenumber.DataArrayInt32_FromVTK94InternalReprOfPolyedra(arrIn, arrIndxIn, arrIndxIn2)
+
+    @staticmethod
+    def FromVTK93To94FacesInternaReprOfPolyedra(arrIn, arrIndxIn):
+        r"""
+        FromVTK93To94FacesInternaReprOfPolyedra(DataArrayInt32 arrIn, DataArrayInt32 arrIndxIn) -> PyObject *
+        1
+        """
+        return _MEDRenumber.DataArrayInt32_FromVTK93To94FacesInternaReprOfPolyedra(arrIn, arrIndxIn)
+
     @staticmethod
     def SetPartOfIndexedArraysSameIdx(li, arrIn, arrIndxIn, srcArr, srcArrIndex):
         r"""
@@ -6092,6 +6211,13 @@ class DataArrayInt64(DataArray):
         """
         return _MEDRenumber.DataArrayInt64_abs(self)
 
+    def sortPerTuple(self, asc):
+        r"""
+        sortPerTuple(DataArrayInt64 self, bool asc)
+        1
+        """
+        return _MEDRenumber.DataArrayInt64_sortPerTuple(self, asc)
+
     def computeAbs(self):
         r"""
         computeAbs(DataArrayInt64 self) -> DataArrayInt64
@@ -6319,6 +6445,13 @@ class DataArrayInt64(DataArray):
         """
         return _MEDRenumber.DataArrayInt64_duplicateEachTupleNTimes(self, nbTimes)
 
+    def duplicateNTimes(self, nbTimes):
+        r"""
+        duplicateNTimes(DataArrayInt64 self, mcIdType nbTimes) -> MCAuto< MEDCoupling::DataArrayInt64 >
+        1
+        """
+        return _MEDRenumber.DataArrayInt64_duplicateNTimes(self, nbTimes)
+
     def getDifferentValues(self):
         r"""
         getDifferentValues(DataArrayInt64 self) -> DataArrayInt64
@@ -6416,6 +6549,21 @@ class DataArrayInt64(DataArray):
         """
         return _MEDRenumber.DataArrayInt64_powEqual(self, other)
 
+    @staticmethod
+    def LoadForDbg(fileName):
+        r"""
+        LoadForDbg(std::string const & fileName) -> MCAuto< MEDCoupling::DataArrayInt64 >
+        1
+        """
+        return _MEDRenumber.DataArrayInt64_LoadForDbg(fileName)
+
+    def writeForDbg(self, fileName):
+        r"""
+        writeForDbg(DataArrayInt64 self, std::string const & fileName)
+        1
+        """
+        return _MEDRenumber.DataArrayInt64_writeForDbg(self, fileName)
+
     def fromLinkedListOfPairToList(self):
         r"""
         fromLinkedListOfPairToList(DataArrayInt64 self) -> MCAuto< MEDCoupling::DataArrayInt64 >
@@ -6967,6 +7115,20 @@ class DataArrayInt64(DataArray):
         """
         return _MEDRenumber.DataArrayInt64_findIdsRangesInListOfIds(self, listOfIds)
 
+    def forThisAsPartitionBuildReduction(self, commonEntities, commonEntitiesIndex):
+        r"""
+        forThisAsPartitionBuildReduction(DataArrayInt64 self, DataArrayInt32 commonEntities, DataArrayInt32 commonEntitiesIndex) -> PyObject *
+        1
+        """
+        return _MEDRenumber.DataArrayInt64_forThisAsPartitionBuildReduction(self, commonEntities, commonEntitiesIndex)
+
+    def fromListOfPairsToIndexArray(self):
+        r"""
+        fromListOfPairsToIndexArray(DataArrayInt64 self) -> PyObject *
+        1
+        """
+        return _MEDRenumber.DataArrayInt64_fromListOfPairsToIndexArray(self)
+
     def isRange(self):
         r"""
         isRange(DataArrayInt64 self) -> PyObject *
@@ -6982,6 +7144,13 @@ class DataArrayInt64(DataArray):
         """
         return _MEDRenumber.DataArrayInt64_RemoveIdsFromIndexedArrays(li, arr, arrIndx, offsetForRemoval)
 
+    def findCommonTuples(self, limitNodeId=-1):
+        r"""
+        findCommonTuples(DataArrayInt64 self, mcIdType limitNodeId=-1) -> PyObject
+        1
+        """
+        return _MEDRenumber.DataArrayInt64_findCommonTuples(self, limitNodeId)
+
     @staticmethod
     def ExtractFromIndexedArrays(li, arrIn, arrIndxIn):
         r"""
@@ -7007,6 +7176,30 @@ class DataArrayInt64(DataArray):
         """
         return _MEDRenumber.DataArrayInt64_SetPartOfIndexedArrays(li, arrIn, arrIndxIn, srcArr, srcArrIndex)
 
+    @staticmethod
+    def FromVTKInternalReprOfPolyedra(arrIn, arrIndxIn):
+        r"""
+        FromVTKInternalReprOfPolyedra(DataArrayInt64 arrIn, DataArrayInt32 arrIndxIn) -> PyObject *
+        1
+        """
+        return _MEDRenumber.DataArrayInt64_FromVTKInternalReprOfPolyedra(arrIn, arrIndxIn)
+
+    @staticmethod
+    def FromVTK94InternalReprOfPolyedra(arrIn, arrIndxIn, arrIndxIn2):
+        r"""
+        FromVTK94InternalReprOfPolyedra(DataArrayInt64 arrIn, DataArrayInt32 arrIndxIn, DataArrayInt32 arrIndxIn2) -> PyObject *
+        1
+        """
+        return _MEDRenumber.DataArrayInt64_FromVTK94InternalReprOfPolyedra(arrIn, arrIndxIn, arrIndxIn2)
+
+    @staticmethod
+    def FromVTK93To94FacesInternaReprOfPolyedra(arrIn, arrIndxIn):
+        r"""
+        FromVTK93To94FacesInternaReprOfPolyedra(DataArrayInt64 arrIn, DataArrayInt32 arrIndxIn) -> PyObject *
+        1
+        """
+        return _MEDRenumber.DataArrayInt64_FromVTK93To94FacesInternaReprOfPolyedra(arrIn, arrIndxIn)
+
     @staticmethod
     def SetPartOfIndexedArraysSameIdx(li, arrIn, arrIndxIn, srcArr, srcArrIndex):
         r"""
@@ -9089,6 +9282,13 @@ class MEDCouplingFieldDiscretizationOnNodesFE(MEDCouplingFieldDiscretizationOnNo
         1
         """
         return _MEDRenumber.MEDCouplingFieldDiscretizationOnNodesFE_getCooInRefElement(self, mesh, locs)
+
+    def getClosestCooInRefElement(self, mesh, locs):
+        r"""
+        getClosestCooInRefElement(MEDCouplingFieldDiscretizationOnNodesFE self, MEDCouplingMesh mesh, PyObject * locs) -> DataArrayDouble
+        1
+        """
+        return _MEDRenumber.MEDCouplingFieldDiscretizationOnNodesFE_getClosestCooInRefElement(self, mesh, locs)
     __swig_destroy__ = _MEDRenumber.delete_MEDCouplingFieldDiscretizationOnNodesFE
 
 # Register MEDCouplingFieldDiscretizationOnNodesFE in _MEDRenumber:
@@ -10049,6 +10249,13 @@ class MEDCouplingUMesh(MEDCouplingPointSet):
         """
         return _MEDRenumber.MEDCouplingUMesh_changeOrientationOfCells(self)
 
+    def orientCorrectly3DCells(self):
+        r"""
+        orientCorrectly3DCells(MEDCouplingUMesh self)
+        1
+        """
+        return _MEDRenumber.MEDCouplingUMesh_orientCorrectly3DCells(self)
+
     def computeCellCenterOfMassWithPrecision(self, eps):
         r"""
         computeCellCenterOfMassWithPrecision(MEDCouplingUMesh self, double eps) -> DataArrayDouble
@@ -10124,6 +10331,20 @@ class MEDCouplingUMesh(MEDCouplingPointSet):
         """
         return _MEDRenumber.MEDCouplingUMesh_Build1DMeshFromCoords(da)
 
+    def convertToQuadraticBasedOnSeg3(self, seg3):
+        r"""
+        convertToQuadraticBasedOnSeg3(MEDCouplingUMesh self, MEDCoupling1SGTUMesh * seg3) -> MEDCouplingUMesh
+        1
+        """
+        return _MEDRenumber.MEDCouplingUMesh_convertToQuadraticBasedOnSeg3(self, seg3)
+
+    def extrudeConnectivity(self, nbOfCellsToExtrude):
+        r"""
+        extrudeConnectivity(MEDCouplingUMesh self, mcIdType nbOfCellsToExtrude) -> MEDCouplingUMesh
+        1
+        """
+        return _MEDRenumber.MEDCouplingUMesh_extrudeConnectivity(self, nbOfCellsToExtrude)
+
     def getAllGeoTypesSorted(self):
         r"""
         getAllGeoTypesSorted(MEDCouplingUMesh self) -> PyObject *