medcoupling 9.13.0__cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

VTKReader.py

@@ -0,0 +1,306 @@
+#  -*- 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)
+
+from MEDLoader import *
+
+class PVDReader:
+    @classmethod
+    def New(cls,fileName):
+        """ Static constructor. """
+        return PVDReader(fileName)
+        pass
+
+    def __init__(self,fileName):
+        self._fileName=fileName
+        pass
+
+    def loadTopInfo(self):
+        fd=open(self._fileName,"r")
+        return self.__parseXML(fd)
+
+    def __parseXML(self,fd):
+        import xml.sax
+        class PVD_SAX_Reader(xml.sax.ContentHandler):
+            def __init__(self):
+                self._tsteps=[]
+                pass
+            def startElement(self,name,attrs):
+                if name=="VTKFile":
+                    if attrs["type"]!="Collection":
+                        raise Exception("Mismatch between reader (PVD) type and file content !")
+                    return
+                if name=="DataSet":
+                    self._tsteps.append((float(attrs["timestep"]),str(attrs["file"])))
+                    return
+                pass
+            pass
+        rd=PVD_SAX_Reader()
+        parser=xml.sax.make_parser()
+        parser.setContentHandler(rd)
+        parser.parse(fd)
+        return rd
+    pass
+
+class PVTUReader:
+    @classmethod
+    def New(cls,fileName):
+        """ Static constructor. """
+        return PVTUReader(fileName)
+        pass
+
+    def __init__(self,fileName):
+        self._fileName=fileName
+        pass
+
+    def loadParaInfo(self):
+        fd=open(self._fileName,"r")
+        return self.__parseXML(fd)
+
+    def __parseXML(self,fd):
+        import xml.sax
+        class PVTU_SAX_Reader(xml.sax.ContentHandler):
+            def __init__(self):
+                self._data_array={2:self.DAPointData,3:self.DACellData}
+                self._node_fields=[]
+                self._cell_fields=[]
+                self._pfiles=[]
+                self._tmp=None
+                pass
+            def DAPointData(self,attrs):
+                self._node_fields.append((str(attrs["Name"]),int(attrs["NumberOfComponents"])))
+                pass
+            def DACellData(self,attrs):
+                self._cell_fields.append((str(attrs["Name"]),int(attrs["NumberOfComponents"])))
+                pass
+            def startElement(self,name,attrs):
+                if name=="VTKFile":
+                    if attrs["type"]!="PUnstructuredGrid":
+                        raise Exception("Mismatch between reader (PVTU) type and file content !")
+                    return
+                if name=="Piece":
+                    self._pfiles.append(str(attrs["Source"]))
+                    return
+                if name=="PPointData":
+                    self._tmp=2
+                    return
+                if name=="PCellData":
+                    self._tmp=3
+                    return
+                if name=="PDataArray":
+                    if self._tmp in self._data_array:
+                        self._data_array[self._tmp](attrs)
+                        pass
+                    return
+                pass
+            pass
+        rd=PVTU_SAX_Reader()
+        parser=xml.sax.make_parser()
+        parser.setContentHandler(rd)
+        parser.parse(fd)
+        return rd
+    pass
+
+class VTURawReader:
+    """ Converting a VTU file in raw mode into the MED format.
+    """
+    VTKTypes_2_MC=[-1,0,-1,1,33,3,-1,5,-1,4,14,-1,NORM_HEXA8,16,15,-1,22,-1,-1,-1,-1,2,6,8,20,30,25,23,9,27,-1,-1,-1,-1,7,-1,-1,-1,-1,-1,-1,-1,31]
+
+    class NormalException(Exception):
+        def __init__(self,lineNb):
+            Exception.__init__(self)
+            self._line_nb=lineNb
+        def getLineNb(self):
+            return self._line_nb
+        pass
+    
+    class NotRawVTUException(Exception):
+        pass
+
+    def loadInMEDFileDS(self):
+        import numpy as np
+        fd=open(self._fileName,"r")
+        ref,rd=self.__parseXML(fd)
+        #
+        ret=MEDFileData()
+        ms=MEDFileMeshes() ; ret.setMeshes(ms)
+        fs=MEDFileFields() ; ret.setFields(fs)
+        #
+        types=np.memmap(fd,dtype=rd._type_types,mode='r',offset=ref+rd._off_types,shape=(rd._nb_cells,))
+        types=self.__swapIfNecessary(rd._bo,types)
+        # mesh dimension detection
+        types2=types.copy() ; types2.sort() ; types2=np.unique(types2)
+        meshDim=MEDCouplingMesh.GetDimensionOfGeometricType(self.VTKTypes_2_MC[types2[0]])
+        for typ in types2[1:]:
+            md=MEDCouplingMesh.GetDimensionOfGeometricType(self.VTKTypes_2_MC[typ])
+            if md!=meshDim:
+                raise Exception("MultiLevel umeshes not managed yet !")
+            pass
+        m=MEDCouplingUMesh("mesh",meshDim)
+        # coordinates
+        coo=np.memmap(fd,dtype=rd._type_coords,mode='r',offset=ref+rd._off_coords,shape=(rd._nb_nodes*rd._space_dim,))
+        coo=self.__swapIfNecessary(rd._bo,coo) ; coo=DataArrayDouble(np.array(coo,dtype='float64')) ; coo.rearrange(rd._space_dim)
+        m.setCoords(coo)
+        # connectivity
+        offsets=np.memmap(fd,dtype=rd._type_off,mode='r',offset=ref+rd._off_off,shape=(rd._nb_cells,))
+        offsets=self.__swapIfNecessary(rd._bo,offsets) ; connLgth=offsets[-1] ; offsets2=DataArrayInt(rd._nb_cells+1) ; offsets2.setIJ(0,0,0)
+        offsets2[1:]=DataArrayInt(offsets)
+        offsets3=offsets2.deltaShiftIndex() ; offsets2=offsets3.deepCopy() ; offsets3+=1 ; offsets3.computeOffsetsFull()
+        offsets=offsets3
+        tmp1=DataArrayInt(len(offsets2),2) ; tmp1[:,0]=1 ; tmp1[:,1]=offsets2 ; tmp1.rearrange(1) ; tmp1.computeOffsetsFull()
+        tmp1=DataArrayInt.Range(1,2*len(offsets2),2).buildExplicitArrByRanges(tmp1)
+        conn=np.memmap(fd,dtype=rd._type_conn,mode='r',offset=ref+rd._off_conn,shape=(connLgth,))
+        conn=self.__swapIfNecessary(rd._bo,conn)
+        types=np.array(types,dtype='int32') ; types=DataArrayInt(types) ; types.transformWithIndArr(self.VTKTypes_2_MC)
+        conn2=DataArrayInt(offsets.back())
+        conn2[offsets[0:-1]]=types
+        conn2[tmp1]=DataArrayInt(conn)
+        m.setConnectivity(conn2,offsets,True)
+        m.checkConsistencyLight() ; mm=MEDFileUMesh() ; mm.setMeshAtLevel(0,m) ; ms.pushMesh(mm)
+        # Fields on nodes and on cells
+        for spatialDisc,nbEnt,fields in [(ON_NODES,rd._nb_nodes,rd._node_fields),(ON_CELLS,rd._nb_cells,rd._cell_fields)]: 
+            for name,typ,nbCompo,off in fields:
+                ff=MEDFileFieldMultiTS()
+                f=MEDCouplingFieldDouble(spatialDisc,ONE_TIME)
+                f.setName(name) ; f.setMesh(m)
+                vals=np.memmap(fd,dtype=typ,mode='r',offset=ref+off,shape=(nbEnt*nbCompo))
+                vals=self.__swapIfNecessary(rd._bo,vals)
+                arr=DataArrayDouble(np.array(vals,dtype='float64')) ; arr.rearrange(nbCompo)
+                f.setArray(arr) ; f.checkConsistencyLight()
+                f.setTime(self._time[0],self._time[1],0)
+                ff.appendFieldNoProfileSBT(f)
+                fs.pushField(ff)
+                pass
+            pass
+        return ret
+
+    def __parseXML(self,fd):
+        import xml.sax
+        class VTU_SAX_Reader(xml.sax.ContentHandler):
+            def __init__(self):
+                self._loc=None
+                self._data_array={0:self.DAPoints,1:self.DACells,2:self.DAPointData,3:self.DACellData}
+                self._node_fields=[]
+                self._cell_fields=[]
+                pass
+            def setLocator(self,loc):
+                self._loc=loc
+            def DAPoints(self,attrs):
+                self._space_dim=int(attrs["NumberOfComponents"])
+                self._type_coords=str(attrs["type"]).lower()
+                self._off_coords=int(attrs["offset"])
+                pass
+            def DACells(self,attrs):
+                if attrs["Name"]=="connectivity":
+                    self._type_conn=str(attrs["type"]).lower()
+                    self._off_conn=int(attrs["offset"])
+                    pass
+                if attrs["Name"]=="offsets":
+                    self._type_off=str(attrs["type"]).lower()
+                    self._off_off=int(attrs["offset"])
+                    pass
+                if attrs["Name"]=="types":
+                    self._type_types=str(attrs["type"]).lower()
+                    self._off_types=int(attrs["offset"])
+                    pass
+                pass
+            def DAPointData(self,attrs):
+                self._node_fields.append((str(attrs["Name"]),str(attrs["type"]).lower(),int(attrs["NumberOfComponents"]),int(attrs["offset"])))
+                pass
+            def DACellData(self,attrs):
+                self._cell_fields.append((str(attrs["Name"]),str(attrs["type"]).lower(),int(attrs["NumberOfComponents"]),int(attrs["offset"])))
+                pass
+            def startElement(self,name,attrs):
+                if name=="VTKFile":
+                    if attrs["type"]!="UnstructuredGrid":
+                        raise Exception("Mismatch between reader (VTU) type and file content !")
+                    self._bo=bool(["LittleEndian","BigEndian"].index(attrs["byte_order"]))
+                    pass
+                if name=="Piece":
+                    self._nb_cells=int(attrs["NumberOfCells"])
+                    self._nb_nodes=int(attrs["NumberOfPoints"])
+                    return
+                if name=="Points":
+                    self._tmp=0
+                    return
+                if name=="Cells":
+                    self._tmp=1
+                    return
+                if name=="PointData":
+                    self._tmp=2
+                    return
+                if name=="CellData":
+                    self._tmp=3
+                    return
+                if name=="DataArray":
+                    self._data_array[self._tmp](attrs)
+                    return
+                if name=="AppendedData":
+                    if str(attrs["encoding"])=="raw":
+                        raise VTURawReader.NormalException(self._loc.getLineNumber())
+                    else:
+                        raise VTURawReader.NotRawVTUException("The file is not a raw VTU ! Change reader !")
+                pass
+            pass
+        rd=VTU_SAX_Reader()
+        parser=xml.sax.make_parser()
+        parser.setContentHandler(rd)
+        locator=xml.sax.expatreader.ExpatLocator(parser)
+        rd.setLocator(locator)
+        isOK=False
+        try:
+            parser.parse(fd)
+        except self.NormalException as e:
+            isOK=True
+            fd.seek(0)
+            for i in range(e.getLineNb()): fd.readline()
+            ref=fd.tell()+5
+            pass
+        if not isOK:
+            raise Exception("Error in VTURawReader : not a raw format ?")
+        return ref,rd
+
+    @classmethod
+    def New(cls,fileName,tim=(0.,0)):
+        """ Static constructor. """
+        return VTURawReader(fileName,tim)
+        pass
+
+    def __init__(self,fileName,tim=(0.,0)):
+        msg="The time specified in constructor as 2nd arg should be a tuple containing 2 values 1 float and 1 int !"
+        if not isinstance(tim, tuple):
+            raise Exception(msg)
+        if len(tim)!=2:
+            raise Exception(msg)
+        if not isinstance(tim[0], float) or not isinstance(tim[1], int):
+            raise Exception(msg)
+        self._fileName=fileName
+        self._time=tim
+        pass
+
+    def __swapIfNecessary(self,b,arr):
+        if b:
+            ret=arr.copy()
+            ret.byteswap(True)
+            return ret
+        else:
+            return arr
+        pass
+    pass

geom2medcoupling.py

@@ -0,0 +1,99 @@
+#! /usr/bin/env python3
+#  -*- coding: utf-8 -*-
+# Copyright (C) 2021-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 (EDF R&D)
+
+import medcoupling as mc
+
+def __to_geomshape_3D(mcmesh):
+    """
+    Precondition mcmesh is a MEDCouplingUMesh containing exactly one linear 3D cell.
+    """
+    import salome
+    salome.standalone()
+    salome.salome_init()
+    import GEOM
+    from salome.geom import geomBuilder
+    geompy = geomBuilder.New()
+
+    mcmesh2 = mcmesh.deepCopyConnectivityOnly()
+    vertices = [ geompy.MakeVertex(*list(elt)) for elt in mcmesh2.getCoords()]
+
+    mcfaces = mcmesh2.buildDescendingConnectivity()[0]
+    shell_1 = geompy.MakeShell(
+        [
+            geompy.MakeFaceWires(
+                [
+                    geompy.MakePolyline([ vertices[nodeidx] for nodeidx in elt.getAllConn()[1:] ], True)
+                ]
+                , 1
+            )
+        for elt in mcfaces ]
+        )
+    return geompy.MakeSolid([shell_1])
+
+def to_geomshape(mcmesh):
+    """
+    Method converting a unique 3D linear cell in a MEDCoupling mesh to GEOM Shape solid
+
+    :param mcmesh: Mesh with single 3D linear cell.
+    :type mcmesh: mc.MEDCouplingUMesh
+    :return: GEOM shape
+    :rtype: GEOM_Object
+    """
+    if not isinstance(mcmesh,mc.MEDCouplingUMesh):
+        raise RuntimeError("Input mesh is expected to be of type mc.MEDCouplingUMesh !")
+    if mcmesh.getNumberOfCells() != 1:
+        raise RuntimeError("Input mesh is expected to contain exactly one cell !")
+    if not mc.MEDCouplingUMesh.IsLinearGeometricType( mc.MEDCoupling1SGTUMesh(mcmesh).getCellModelEnum() ) :
+        raise RuntimeError("The unique cell in the mesh is expected to be linear !")
+    dico = { 3 : __to_geomshape_3D }
+    mdim = mcmesh.getMeshDimension()
+    if mdim not in dico:
+        raise RuntimeError( "Input mesh is expected to have mesh dimension in {}".format(list(dico.keys())) )
+    if mcmesh.getSpaceDimension() != 3:
+        mcmesh.changeSpaceDimension(3,0.0)
+    return (dico[mdim])(mcmesh)
+
+def compute_interpolation_P0P0_matrix_with_geom(srcMesh,trgMesh):
+    """
+    Method computing interpolation matrix P0P0 using GEOM/OCCT engine.
+    This method is normaly slower than mc.MEDCouplingRemapper.prepare method but it may be used to check values.
+
+    :return: a matrix with the same format than mc.MEDCouplingRemapper.getCrudeMatrix (use mc.MEDCouplingRemapper.ToCSRMatrix to convert it into scipy sparse format)
+    """
+    mat_geom = [ {} for i in range(trgMesh.getNumberOfCells()) ]
+    for j in range(trgMesh.getNumberOfCells()):
+        for i in range(srcMesh.getNumberOfCells()):
+            mc_src_mesh = srcMesh[i]
+            src_geom = to_geomshape(mc_src_mesh)
+            mc_trg_mesh = trgMesh[j]
+            trg_geom = to_geomshape(mc_trg_mesh)
+
+            from salome.geom import geomBuilder
+            geompy = geomBuilder.New()
+            import GEOM
+            geompy.ExportBREP(src_geom, "src.brep")
+            geompy.ExportBREP(trg_geom, "trg.brep")
+            Common_1 = geompy.MakeCommonList([src_geom, trg_geom], True)
+            _,_,volume = geompy.BasicProperties(Common_1)
+            if volume > 0.:
+                mat_geom[j][i] = volume
+    return mat_geom

medcoupling-9.13.0.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 1.2
+Name: medcoupling
+Version: 9.13.0
+Summary: Powerful library to manipulate meshes and fields
+Home-page: https://docs.salome-platform.org/latest/dev/MEDCoupling/developer/index.html
+Author: EDF R&D
+Author-email: eric.fayolle@edf.fr
+License: LGPL
+Keywords: salome mesh numerical simulation
+Platform: any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Intended Audience :: Science/Research
+Requires-Dist: scipy
+
+
+# MEDCoupling
+
+[![pypi](https://img.shields.io/pypi/v/medcoupling.svg?style=flat-square)](https://pypi.org/project/medcoupling)
+https://github.com/jschueller/medcoupling-wheels
+[![github](https://github.com/jschueller/medcoupling-wheels/actions/workflows/stable.yml/badge.svg?branch=master)](https://github.com/jschueller/medcoupling-wheels/actions/workflows/stable.yml)
+
+
+MEDCoupling is a powerful library to manipulate meshes and fields from the [SALOME](https://www.salome-platform.org/) platform.
+
+Refer to the [documentation](https://docs.salome-platform.org/latest/dev/MEDCoupling/developer/index.html).
+
+## Installation from PyPI
+
+To install MEDCoupling, you can now simply do
+
+```
+pip install -U medcoupling
+```
+
+Binary wheels are available for 64-bit Windows (`win_amd64`) and Linux-like platforms (`manylinux2014_x86_64`).
+
+To ensure that MEDCoupling is well installed, try importing it with:
+
+```
+import medcoupling  # should not raise error
+```

medcoupling-9.13.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+MEDLoader.py,sha256=-FLOJhrBhKJb8KEG_qGdI_DB6zaf434xL9cKhBcjQIM,749459
+_MEDPartitioner.so,sha256=rqvWSK7AgJnxRZmx9nRVgg2Q0h5mfm2W6uHYlBNUtn8,97857
+MEDCoupling.py,sha256=j_WY2soH7HhphnsCYpPDWTLeVeHaC2XP4asksWhyPic,509931
+_MEDCouplingRemapper.so,sha256=z9rmodrjYYFer68x62HoHtlEUg20KA_V1x8ecfJRlhs,5674201
+CaseIO.py,sha256=BB_-bq1Ht94ewqCjc0VIWNBAdu6Tuht_BM_drGXz35U,1704
+MEDRenumber.py,sha256=LyKwT0a2jbMTOYB-3hPLSRAmcOJtoZ1cj_I3xRSL2Ak,505417
+_MEDLoader.so,sha256=VU4WoaTlPIryvAiU1Dsddu2pwPV13fzzN8OlxZ1gu3s,8003289
+MEDPartitioner.py,sha256=hobviqMFcRteNSQgDAnK2qM_aMjeVSsWalVobNKrR9c,5635
+vtk2medcoupling.py,sha256=jZ5GzBc750YQjtVFNWKsMKsmzPyohJbqHy1AfhlULKI,2703
+CaseWriter.py,sha256=aViDtqDBHzZDTOlVi7r_xQJFS30qsVbGGlIX6YC3MZA,16019
+_MEDRenumber.so,sha256=lG-PEIBWWttTCZEx7D5OEUTXMmKhxdKhuPbpGKr83UA,5564153
+MEDLoaderSplitter.py,sha256=1tL7UpYpn2bxlAmc1t9TOXfJWid_GdaLIdZfpmR39rw,9158
+VTKReader.py,sha256=UfcqicvU1IUexPDk_RqenFgFzyMKA12htuKZNosh6Aw,12295
+_medcoupling.so,sha256=TZuoJm3n9fETOtOH5pROx5-0wRF7hc5kl90eL1j__u0,8218497
+_MEDCoupling.so,sha256=_OZTwUqTjxp6TueqHVk2qHVCshIxZHucwIGoVmY4KWQ,5547241
+medcoupling.py,sha256=L4L0Eqz5i3rgwVx_NPthsCU5_QwNW6cNT6ZvSIrqti8,787380
+geom2medcoupling.py,sha256=fRVN2odT4GnapKYjPlaAdBZkOlMQiLHRYodNNsuddO0,4010
+MEDLoaderFinalize.py,sha256=6T1n5w30lrEJcDZrfnSx8mN0eocM0fGhCkKTBHRvlXI,2728
+CaseReader.py,sha256=F7ME-G9iaRFgMyKYo4FO-nO0fnyw1Eeflkc0MvGi8D0,19770
+MEDCouplingRemapper.py,sha256=MmyEeNKSyV8AdbDbTx5XY02MYEMWgKp80ySumetyclI,548270
+medcoupling-9.13.0.dist-info/RECORD,,
+medcoupling-9.13.0.dist-info/METADATA,sha256=DvTOETA7T1iZwEgfyx6z2U4iK-P-9LGXKLsa5BQhGD8,1647
+medcoupling-9.13.0.dist-info/WHEEL,sha256=jtnYk5S9Zo1kkQy8lGIiYH1bpe4azcMnAVeUSP_xDVQ,138
+medcoupling.libs/librenumbercpp-8a16a450.so,sha256=kdhXGiZXKbrccn3WVg9yDEOJg75-mdr7zxRG4YRFcLU,84497
+medcoupling.libs/libmedicoco-ba7f6be6.so,sha256=biCOVrNCbEPd_pzfzgph74YTYzfE7iJxAsJNbW9X1UA,34937
+medcoupling.libs/libhdf5-1c824725.so.103.0.0,sha256=OQXq7WSq1h_CkwiDLG2mYs-Gwv9tx2H_eMDHmtvUcPE,4322561
+medcoupling.libs/libmedcouplingremapper-9bb9d18f.so,sha256=Ngq2RFrwvnYUkZcnI41JStl4Gz9VfRzxXmaSaEotAYg,1868961
+medcoupling.libs/libmedloader-deccdcc9.so,sha256=DjMBfHZT8EysX-e8RvMizqx2VzITOy8U1PIUErEco08,5297457
+medcoupling.libs/libmetis-ace54c0c.so,sha256=jf3MihOTbkdEKNt3WHnVPk1jfeo7TvrUDURkbUSsl84,640849
+medcoupling.libs/libmedfwrap-292e4f7f.so.11.1.1,sha256=U_mTsti2FlQ3tql82Dl_3jtMBBVQLNJS_uLAuz1cvUA,274105
+medcoupling.libs/libmedC-33a5e5d1.so.11.1.1,sha256=FUxXbAGR1hqHqImkOm-l3h7EtxETfa5Q4Kvgf-wYty0,1364401
+medcoupling.libs/libgfortran-040039e1.so.5.0.0,sha256=FK-zEpsai1C8QKOwggx_EVLqm8EBIaqxUpQ_cFdHKIY,2686065
+medcoupling.libs/libquadmath-96973f99.so.0.0.0,sha256=k0wi3tDn0WnE1GeIdslgUa3z2UVF2pYvYLQWWbB12js,247609
+medcoupling.libs/libxml2-e666f9db.so.2.10.3,sha256=OApRLNO_-41N40CuL4-4_ztVkP23V5DwcZjhJHzKMys,6113673
+medcoupling.libs/libmedcoupling-837c78c0.so,sha256=fH0-OkrMvpHzaUR6HzlGnACsCXat6La-lG4bzn4xPeM,6317145
+medcoupling.libs/libmedpartitionercpp-c7f41708.so,sha256=LABirFAyG6Ui6bfa2CnKuuEo7clyNhRslP4YzxBdAzE,583265
+medcoupling.libs/libinterpkernel-71542653.so,sha256=v2xsc4E0XBGooR2Pnisl_eNFEWbvR599cgkrZBa0wlk,1586025

medcoupling-9.13.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: custom
+Root-Is-Purelib: false
+Tag: cp313-cp313-manylinux2014_x86_64
+Tag: cp313-cp313-manylinux_2_17_x86_64
+