medcoupling 9.13.0__cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

MEDLoaderFinalize.py

@@ -0,0 +1,66 @@
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2023-2024  CEA, EDF
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+def MEDFileUMeshReduceToCells(self, level, keepCells, removeOrphanNodes=True):
+    """
+    Method returning a new MEDFileUMesh, restriction of self to level and keepCell cells at this level.
+    This method also 
+
+    :param level: Specifies the top level of the returned MEDFileUMesh expected
+    :param keepCells: A DataArrayInt specifying cell ids at level level of self
+    :param removeOrphanNodes: Specifies if orphan nodes should be removed at the end
+    
+    see also MEDFileUMesh.extractPart
+    """
+    import MEDLoader as ml
+    subLevs = [l for l in self.getNonEmptyLevels() if l<=level]
+    subMeshes = [self[lev] for lev in subLevs]
+    allFamilyFields = [self.getFamilyFieldAtLevel(lev) for lev in subLevs]
+    allRefMesh = subMeshes[0]
+    refMesh = allRefMesh[keepCells]
+
+    mmOut = ml.MEDFileUMesh()
+    # level 0
+    mmOut[0] = refMesh
+    mmOut.setFamilyFieldArr(0,allFamilyFields[0][keepCells])
+
+    # subLevels
+    for curLev,meshLev,famFieldLev in zip(subLevs[1:],subMeshes[1:],allFamilyFields[1:]):
+        allMeshLev,d,di, rd,rdi = allRefMesh.explodeMeshTo( curLev-level )
+        a,b = allMeshLev.areCellsIncludedIn(meshLev,2)
+        if not a:
+            raise RuntimeError("Error in mesh {}")
+        dlev,dlevi = ml.DataArrayInt.ExtractFromIndexedArrays( keepCells, d,di )
+        dlev2 = dlev.buildUniqueNotSorted()
+        cellsToKeepLev = ml.DataArrayInt.BuildIntersection([dlev2,b])
+        cellsToKeepLev = b.indicesOfSubPart(cellsToKeepLev)
+        cellsToKeepLev.sort()
+        mmOut[curLev] = meshLev[cellsToKeepLev]
+        mmOut.setFamilyFieldArr(curLev,famFieldLev[cellsToKeepLev])
+
+    allFamNodes = mmOut.getFamilyFieldAtLevel(1)
+    if allFamNodes:
+        mmOut.setFamilyFieldArr(1,allFamNodes[:])
+
+    if removeOrphanNodes:
+        mmOut.zipCoords()
+
+    mmOut.copyFamGrpMapsFrom(self)
+    return mmOut

MEDLoaderSplitter.py

@@ -0,0 +1,199 @@
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024  CEA, EDF
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+# Author : Anthony GEAY (CEA/DEN/DM2S/STMF/LGLS)
+
+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)
+        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:
+            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)
+            pass
+        pass
+
+    def getSplittedInstances(self):
+        return self._mfd_splitted
+    
+    @classmethod
+    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):
+                zeLev = lev
+                break
+        assert(zeLev is not None)
+        cache[(fieldName,procID)]["zeLev"]=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 
+        #
+        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.zipCoords()
+        #
+        res=pfl.findIdForEach(subProfileInProc)
+        subProfileInProcReducedNode=subProfileInProc.deepCopy() ; subProfileInProcReducedNode.transformWithIndArr(trado2n)
+        subProfileInProcReducedNode.setName(pfl.getName())
+        #
+        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)
+            #
+            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):
+                return
+            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)
+                pass
+            #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]
+            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)
+        f1tsOut.setFieldNoProfileSBT(fRet)
+        pass
+    
+    def __splitMEDFileField1TS(self,mm,mmOutList,f1ts,idsLst,cache):
+        """
+           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.
+        """
+        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)
+                pass
+            pass
+        return ret
+    
+    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))]
+            for f1ts in fmts:
+                for fmtsPart,f1tsPart in zip(ret1,self.__splitMEDFileField1TS(mm,mmOutList,f1ts,idsLst,cache)):
+                    if f1tsPart.getUndergroundDataArray():
+                        if len(f1tsPart.getUndergroundDataArray())!=0 :
+                            fmtsPart.pushBackTimeStep(f1tsPart)
+                    pass
+                pass
+            for fieldsPart,fmtsPart in zip(ret0,ret1):
+                if len(fmtsPart) != 0 :
+                    fieldsPart.pushField(fmtsPart);
+                pass
+            pass
+        return ret0
+
+    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
+            if 0 in mfm.getFamArrNonEmptyLevelsExt():
+                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])
+                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])
+                if k in mfm.getNameArrNonEmptyLevelsExt():
+                    mlPart.setNameFieldAtLevel(k, mfm.getNameFieldAtLevel(k)[part])
+            mlPart.copyFamGrpMapsFrom(mfm)
+            ret.pushMesh(mlPart)
+            pass
+        return ret0
+    pass

MEDPartitioner.py

@@ -0,0 +1,163 @@
+# This file was automatically generated by SWIG (https://www.swig.org).
+# Version 4.2.1
+#
+# Do not make changes to this file unless you know what you are doing - modify
+# the SWIG interface file instead.
+
+from sys import version_info as _swig_python_version_info
+# Import the low-level C/C++ module
+if __package__ or "." in __name__:
+    from . import _MEDPartitioner
+else:
+    import _MEDPartitioner
+
+try:
+    import builtins as __builtin__
+except ImportError:
+    import __builtin__
+
+def _swig_repr(self):
+    try:
+        strthis = "proxy of " + self.this.__repr__()
+    except __builtin__.Exception:
+        strthis = ""
+    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
+
+
+def _swig_setattr_nondynamic_instance_variable(set):
+    def set_instance_attr(self, name, value):
+        if name == "this":
+            set(self, name, value)
+        elif name == "thisown":
+            self.this.own(value)
+        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
+            set(self, name, value)
+        else:
+            raise AttributeError("You cannot add instance attributes to %s" % self)
+    return set_instance_attr
+
+
+def _swig_setattr_nondynamic_class_variable(set):
+    def set_class_attr(cls, name, value):
+        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
+            set(cls, name, value)
+        else:
+            raise AttributeError("You cannot add class attributes to %s" % cls)
+    return set_class_attr
+
+
+def _swig_add_metaclass(metaclass):
+    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
+    def wrapper(cls):
+        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
+    return wrapper
+
+
+class _SwigNonDynamicMeta(type):
+    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
+    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
+
+
+class Graph(object):
+    r"""1"""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def __init__(self, *args, **kwargs):
+        raise AttributeError("No constructor defined")
+    __repr__ = _swig_repr
+    METIS = _MEDPartitioner.Graph_METIS
+    r"""1"""
+    SCOTCH = _MEDPartitioner.Graph_SCOTCH
+    r"""1"""
+    PTSCOTCH = _MEDPartitioner.Graph_PTSCOTCH
+    r"""1"""
+
+    def partGraph(self, *args):
+        r"""
+        partGraph(Graph self, int ndomain, std::string const & options_string="", ParaDomainSelector * sel=None)
+        1
+        """
+        return _MEDPartitioner.Graph_partGraph(self, *args)
+
+    def getGraph(self):
+        r"""
+        getGraph(Graph self) -> MEDCoupling::MEDCouplingSkyLineArray *
+        1
+        """
+        return _MEDPartitioner.Graph_getGraph(self)
+
+    def getPartition(self):
+        r"""
+        getPartition(Graph self) -> MEDCoupling::MEDCouplingSkyLineArray const *
+        1
+        """
+        return _MEDPartitioner.Graph_getPartition(self)
+
+    def nbVertices(self):
+        r"""
+        nbVertices(Graph self) -> int
+        1
+        """
+        return _MEDPartitioner.Graph_nbVertices(self)
+    __swig_destroy__ = _MEDPartitioner.delete_Graph
+
+# Register Graph in _MEDPartitioner:
+_MEDPartitioner.Graph_swigregister(Graph)
+class MEDPartitioner(object):
+    r"""1"""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self, *args):
+        r"""
+        __init__(MEDPartitioner self, std::string const & filename, int ndomains=1, std::string const & library="metis", bool create_boundary_faces=False, bool create_joints=False, bool mesure_memory=False) -> MEDPartitioner
+        __init__(MEDPartitioner self, MEDCoupling::MEDFileData const * fileData, int ndomains=1, std::string const & library="metis", bool create_boundary_faces=False, bool create_joints=False, bool mesure_memory=False) -> MEDPartitioner
+        __init__(MEDPartitioner self, MEDCoupling::MEDFileData const * fileData, Graph graph, bool create_boundary_faces=False, bool create_joints=False, bool mesure_memory=False) -> MEDPartitioner
+        1
+        """
+        _MEDPartitioner.MEDPartitioner_swiginit(self, _MEDPartitioner.new_MEDPartitioner(*args))
+
+    @staticmethod
+    def Graph(*args):
+        r"""
+        Graph(MEDCoupling::MEDCouplingSkyLineArray * graph, MEDPARTITIONER::Graph::splitter_type split=METIS, int * edgeweight=None, MEDCoupling::DataArrayIdType * vlbloctab=None) -> Graph
+        1
+        """
+        return _MEDPartitioner.MEDPartitioner_Graph(*args)
+
+    @staticmethod
+    def AvailableAlgorithms():
+        r"""
+        AvailableAlgorithms() -> std::vector< std::string >
+        1
+        """
+        return _MEDPartitioner.MEDPartitioner_AvailableAlgorithms()
+
+    @staticmethod
+    def AllAlgorithms():
+        r"""
+        AllAlgorithms() -> std::vector< std::string >
+        1
+        """
+        return _MEDPartitioner.MEDPartitioner_AllAlgorithms()
+
+    def getMEDFileData(self):
+        r"""
+        getMEDFileData(MEDPartitioner self) -> MEDCoupling::MEDFileData *
+        1
+        """
+        return _MEDPartitioner.MEDPartitioner_getMEDFileData(self)
+
+    def write(self, filename):
+        r"""
+        write(MEDPartitioner self, std::string const & filename)
+        1
+        """
+        return _MEDPartitioner.MEDPartitioner_write(self, filename)
+    __swig_destroy__ = _MEDPartitioner.delete_MEDPartitioner
+
+# Register MEDPartitioner in _MEDPartitioner:
+_MEDPartitioner.MEDPartitioner_swigregister(MEDPartitioner)
+