medcoupling 9.11.0__cp39-cp39-win_amd64.whl → 9.15.0__cp39-cp39-win_amd64.whl

CaseWriter.py

@@ -1,5 +1,5 @@
 #  -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2023  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,22 +22,23 @@
 import numpy as np
 from CaseIO import CaseIO
 from MEDLoader import *
-import sys,re,os,mmap
+import sys, re, os, mmap
 
 ### www-vis.lbl.gov/NERSC/Software/ensight/doc/OnlineHelp/UM-C11.pdf
 
+
 class CaseWriter(CaseIO):
-    """ Converting MED file format in memory to a the Case file format (Ensight).
+    """Converting MED file format in memory to a the Case file format (Ensight).
     A new file with the same base name and the .case extension is created with its dependencies (.geo ...).
     """
 
-    header="""FORMAT
+    header = """FORMAT
 type: ensight gold
 GEOMETRY
 model: %(geofilewithoutpath)s
 """
-    header_varpart="""VARIABLE"""
-    header_timepart="""TIME
+    header_varpart = """VARIABLE"""
+    header_timepart = """TIME
 time set:               1
 number of steps:        %(NbTimeSteps)i
 filename start number:  0
@@ -48,302 +49,473 @@ time values:
 
     @classmethod
     def New(cls):
-        """ Static constructor. """
+        """Static constructor."""
         return CaseWriter()
         pass
 
     def __init__(self):
-        """ Constructor """
-        self.__export_groups=False
+        """Constructor"""
+        self.__export_groups = False
         pass
 
-    def setMEDFileDS(self,medData):
-        """ Input should be MEDFileData instance  """
-        self._med_data=medData
+    def setMEDFileDS(self, medData):
+        """Input should be MEDFileData instance"""
+        self._med_data = medData
         pass
 
     def isExportingGroups(self):
-        """ return the status of exporting groups policy """
+        """return the status of exporting groups policy"""
         return self.__export_groups
 
-    def setExportingGroups(self,status):
-        assert(isinstance(status,bool))
-        self.__export_groups=status
+    def setExportingGroups(self, status):
+        assert isinstance(status, bool)
+        self.__export_groups = status
         pass
 
-
-    def write(self,fileName):
-        """ Write into the specified fileName series the result """
-        self._file_name=fileName
-        self._base_name_without_dir=os.path.splitext(os.path.basename(self._file_name))[0]
-        self._l=self._file_name.split(os.path.sep) ; self._l[-1]=os.path.splitext(self._l[-1])[0]
-        self._base_name_with_dir=os.path.sep.join(self._l)
-        self._real_written_file_name=[]
-        self._dico={}
+    def write(self, fileName):
+        """Write into the specified fileName series the result"""
+        self._file_name = fileName
+        self._base_name_without_dir = os.path.splitext(
+            os.path.basename(self._file_name)
+        )[0]
+        self._l = self._file_name.split(os.path.sep)
+        self._l[-1] = os.path.splitext(self._l[-1])[0]
+        self._base_name_with_dir = os.path.sep.join(self._l)
+        self._real_written_file_name = []
+        self._dico = {}
         for mesh in self._med_data.getMeshes():
-            additionnalFileNamePart=""
-            if len(self._med_data.getMeshes())!=1:
-                additionnalFileNamePart="_%s"%(mesh.getName())
+            additionnalFileNamePart = ""
+            if len(self._med_data.getMeshes()) != 1:
+                additionnalFileNamePart = "_%s" % (mesh.getName())
                 pass
-            self._dico["geofilewithoutpath"]="%s%s.geo"%(self._base_name_without_dir,additionnalFileNamePart)
-            h0=self.header%self._dico
-            self.__writeMeshesPart(mesh,"%s%s.geo"%(self._base_name_with_dir,additionnalFileNamePart))
+            self._dico["geofilewithoutpath"] = "%s%s.geo" % (
+                self._base_name_without_dir,
+                additionnalFileNamePart,
+            )
+            h0 = self.header % self._dico
+            self.__writeMeshesPart(
+                mesh, "%s%s.geo" % (self._base_name_with_dir, additionnalFileNamePart)
+            )
             #
-            h2=self.__writeFieldsPart(self._med_data.getFields().partOfThisLyingOnSpecifiedMeshName(mesh.getName()))
-            realWrittenCaseFileNameForCurMesh="%s%s.case"%(self._base_name_with_dir,additionnalFileNamePart)
-            fheader=open(realWrittenCaseFileNameForCurMesh,"w") ; fheader.write((h0+h2)%self._dico)
+            h2 = self.__writeFieldsPart(
+                self._med_data.getFields().partOfThisLyingOnSpecifiedMeshName(
+                    mesh.getName()
+                )
+            )
+            realWrittenCaseFileNameForCurMesh = "%s%s.case" % (
+                self._base_name_with_dir,
+                additionnalFileNamePart,
+            )
+            fheader = open(realWrittenCaseFileNameForCurMesh, "w")
+            fheader.write((h0 + h2) % self._dico)
             self._real_written_file_name.append(realWrittenCaseFileNameForCurMesh)
             pass
         return self._real_written_file_name
 
-    def __writeMeshesPart(self,mdm,meshfn):
+    def __writeMeshesPart(self, mdm, meshfn):
         try:
             os.remove(meshfn)
         except:
             pass
-        f=open(meshfn,"w+b")
-        sz=5*80
+        f = open(meshfn, "w+b")
+        sz = 5 * 80
         #
-        assert(isinstance(mdm,MEDFileUMesh))
-        ms2=[[mdm.getMeshAtLevel(lev) for lev in mdm.getNonEmptyLevels()[:1]]]
+        assert isinstance(mdm, MEDFileUMesh)
+        ms2 = [[mdm.getMeshAtLevel(lev) for lev in mdm.getNonEmptyLevels()[:1]]]
         if self.__export_groups:
             for grpnm in mdm.getGroupsNames():
-                ms3=[]
+                ms3 = []
                 for lev in mdm.getGrpNonEmptyLevels(grpnm)[:1]:
-                    m=mdm.getGroup(lev,grpnm) ; m.zipCoords()
+                    m = mdm.getGroup(lev, grpnm)
+                    m.zipCoords()
                     ms3.append(m)
                     pass
                 ms2.append(ms3)
                 pass
             pass
         for ms in ms2:
-            nn=ms[0].getNumberOfNodes()
-            sz+=self.__computeSizeOfGeoFile(ms,nn)
+            nn = ms[0].getNumberOfNodes()
+            sz += self.__computeSizeOfGeoFile(ms, nn)
             pass
         pass
-        a=np.memmap(f,dtype='byte',mode='w+',offset=0,shape=(sz,)) ; a.flush() # truncate to set the size of the file
-        mm=mmap.mmap(f.fileno(),offset=0,length=0)
+        a = np.memmap(f, dtype="byte", mode="w+", offset=0, shape=(sz,))
+        a.flush()  # truncate to set the size of the file
+        mm = mmap.mmap(f.fileno(), offset=0, length=0)
         mm.write(self.__str80("C Binary"))
-        mm.write(self.__str80("Exported from MEDCoupling/MEDLoader version %s"%(MEDCouplingVersionStr())))
+        mm.write(
+            self.__str80(
+                "Exported from MEDCoupling/MEDLoader version %s"
+                % (MEDCouplingVersionStr())
+            )
+        )
         mm.write(self.__str80("Conversion using CaseWriter class"))
         mm.write(self.__str80("node id off"))
         mm.write(self.__str80("element id off"))
-        for iii,ms in enumerate(ms2):
-            nn=ms[0].getNumberOfNodes()
+        for iii, ms in enumerate(ms2):
+            nn = ms[0].getNumberOfNodes()
             mm.write(self.__str80("part"))
-            a=np.memmap(f,dtype='int32',mode='w+',offset=mm.tell(),shape=(1,))
-            a[0]=iii+1 ; a.flush() ; mm.seek(mm.tell()+4) # part number maybe to change ?
-            name=ms[0].getName()
-            if iii>0:
-                name="%s_%s"%(ms2[0][0].getName(),name)
+            a = np.memmap(f, dtype="int32", mode="w+", offset=mm.tell(), shape=(1,))
+            a[0] = iii + 1
+            a.flush()
+            mm.seek(mm.tell() + 4)  # part number maybe to change ?
+            name = ms[0].getName()
+            if iii > 0:
+                name = "%s_%s" % (ms2[0][0].getName(), name)
                 pass
             mm.write(self.__str80(name))
             mm.write(self.__str80("coordinates"))
-            a=np.memmap(f,dtype='int32',mode='w+',offset=mm.tell(),shape=(1,))
-            a[0]=nn ; a.flush() # number of nodes
-            mm.seek(mm.tell()+4)
-            coo=ms[0].getCoords()
-            spaceDim=coo.getNumberOfComponents()
-            if spaceDim!=3:
-                coo=coo.changeNbOfComponents(3,0.)
+            a = np.memmap(f, dtype="int32", mode="w+", offset=mm.tell(), shape=(1,))
+            a[0] = nn
+            a.flush()  # number of nodes
+            mm.seek(mm.tell() + 4)
+            coo = ms[0].getCoords()
+            spaceDim = coo.getNumberOfComponents()
+            if spaceDim != 3:
+                coo = coo.changeNbOfComponents(3, 0.0)
                 pass
-            a=np.memmap(f,dtype='float32',mode='w+',offset=mm.tell(),shape=(3,nn))
-            c=coo.toNoInterlace() ; c.rearrange(1) ; cnp=c.toNumPyArray() ; cnp=cnp.reshape(3,nn)
-            a[:]=cnp ; a.flush() ; mm.seek(mm.tell()+3*nn*4)
+            a = np.memmap(
+                f, dtype="float32", mode="w+", offset=mm.tell(), shape=(3, nn)
+            )
+            c = coo.toNoInterlace()
+            c.rearrange(1)
+            cnp = c.toNumPyArray()
+            cnp = cnp.reshape(3, nn)
+            a[:] = cnp
+            a.flush()
+            mm.seek(mm.tell() + 3 * nn * 4)
             for m in ms:
-                i=0
-                for typ2,nbelem,dummy in m.getDistributionOfTypes():
-                    typ=typ2
+                i = 0
+                for typ2, nbelem, dummy in m.getDistributionOfTypes():
+                    typ = typ2
                     if typ not in self.dictMCTyp:
-                        typ=MEDCouplingMesh.GetCorrespondingPolyType(typ)
+                        typ = MEDCouplingMesh.GetCorrespondingPolyType(typ)
                         pass
-                    mp=m[i:i+nbelem]
+                    mp = m[i : i + nbelem]
                     mm.write(self.__str80(self.dictMCTyp_str[typ]))
-                    a=np.memmap(f,dtype='int32',mode='w+',offset=mm.tell(),shape=(1,))
-                    a[0]=nbelem ; a.flush() ; mm.seek(mm.tell()+4)
-                    if typ!=NORM_POLYHED and typ!=NORM_POLYGON:
-                        nbNodesPerElem=MEDCouplingMesh.GetNumberOfNodesOfGeometricType(typ)
-                        c=mp.getNodalConnectivity() ; c.rearrange(nbNodesPerElem+1) ; c=c[:,1:] ; c.rearrange(1) ; c+=1
-                        a=np.memmap(f,dtype='int32',mode='w+',offset=mm.tell(),shape=(nbNodesPerElem*nbelem,))
-                        a[:]=c.toNumPyArray() ; a.flush() ; mm.seek(mm.tell()+nbNodesPerElem*nbelem*4)
+                    a = np.memmap(
+                        f, dtype="int32", mode="w+", offset=mm.tell(), shape=(1,)
+                    )
+                    a[0] = nbelem
+                    a.flush()
+                    mm.seek(mm.tell() + 4)
+                    if typ != NORM_POLYHED and typ != NORM_POLYGON:
+                        nbNodesPerElem = (
+                            MEDCouplingMesh.GetNumberOfNodesOfGeometricType(typ)
+                        )
+                        c = mp.getNodalConnectivity()
+                        c.rearrange(nbNodesPerElem + 1)
+                        c = c[:, 1:]
+                        c.rearrange(1)
+                        c += 1
+                        a = np.memmap(
+                            f,
+                            dtype="int32",
+                            mode="w+",
+                            offset=mm.tell(),
+                            shape=(nbNodesPerElem * nbelem,),
+                        )
+                        a[:] = c.toNumPyArray()
+                        a.flush()
+                        mm.seek(mm.tell() + nbNodesPerElem * nbelem * 4)
                         pass
-                    elif typ==NORM_POLYHED:
+                    elif typ == NORM_POLYHED:
                         mp.orientCorrectlyPolyhedrons()
-                        c=mp.computeNbOfFacesPerCell()
-                        a=np.memmap(f,dtype='int32',mode='w+',offset=mm.tell(),shape=(nbelem,))
-                        a[:]=c.toNumPyArray(); a.flush() ; mm.seek(mm.tell()+nbelem*4)
-                        c=mp.getNodalConnectivity()[:] ; c.pushBackSilent(-1) ; c[mp.getNodalConnectivityIndex()[:-1]]=-1 ; ids=c.findIdsEqual(-1) ; nbOfNodesPerFace=ids.deltaShiftIndex()-1
-                        a=np.memmap(f,dtype='int32',mode='w+',offset=mm.tell(),shape=(len(nbOfNodesPerFace),))
-                        a[:]=nbOfNodesPerFace.toNumPyArray() ; a.flush() ; mm.seek(mm.tell()+len(nbOfNodesPerFace)*4)
-                        ids2=ids.buildComplement(ids.back()+1)
-                        c2=mp.getNodalConnectivity()[ids2]+1
-                        a=np.memmap(f,dtype='int32',mode='w+',offset=mm.tell(),shape=(len(c2),))
-                        a[:]=c2.toNumPyArray() ; a.flush() ; mm.seek(mm.tell()+len(c2)*4)
+                        c = mp.computeNbOfFacesPerCell()
+                        a = np.memmap(
+                            f,
+                            dtype="int32",
+                            mode="w+",
+                            offset=mm.tell(),
+                            shape=(nbelem,),
+                        )
+                        a[:] = c.toNumPyArray()
+                        a.flush()
+                        mm.seek(mm.tell() + nbelem * 4)
+                        c = mp.getNodalConnectivity()[:]
+                        c.pushBackSilent(-1)
+                        c[mp.getNodalConnectivityIndex()[:-1]] = -1
+                        ids = c.findIdsEqual(-1)
+                        nbOfNodesPerFace = ids.deltaShiftIndex() - 1
+                        a = np.memmap(
+                            f,
+                            dtype="int32",
+                            mode="w+",
+                            offset=mm.tell(),
+                            shape=(len(nbOfNodesPerFace),),
+                        )
+                        a[:] = nbOfNodesPerFace.toNumPyArray()
+                        a.flush()
+                        mm.seek(mm.tell() + len(nbOfNodesPerFace) * 4)
+                        ids2 = ids.buildComplement(ids.back() + 1)
+                        c2 = mp.getNodalConnectivity()[ids2] + 1
+                        a = np.memmap(
+                            f,
+                            dtype="int32",
+                            mode="w+",
+                            offset=mm.tell(),
+                            shape=(len(c2),),
+                        )
+                        a[:] = c2.toNumPyArray()
+                        a.flush()
+                        mm.seek(mm.tell() + len(c2) * 4)
                         pass
                     else:
-                        nbOfNodesPerCell=mp.getNodalConnectivityIndex().deltaShiftIndex()-1
-                        a=np.memmap(f,dtype='int32',mode='w+',offset=mm.tell(),shape=(len(nbOfNodesPerCell),))
-                        a[:]=nbOfNodesPerCell.toNumPyArray() ; a.flush() ; mm.seek(mm.tell()+len(nbOfNodesPerCell)*4)
-                        ids2=mp.getNodalConnectivityIndex().buildComplement(mp.getNodalConnectivityIndex().back()+1)
-                        c2=mp.getNodalConnectivity()[ids2]+1
-                        a=np.memmap(f,dtype='int32',mode='w+',offset=mm.tell(),shape=(len(c2),))
-                        a[:]=c2.toNumPyArray() ; a.flush() ; mm.seek(mm.tell()+len(c2)*4)
+                        nbOfNodesPerCell = (
+                            mp.getNodalConnectivityIndex().deltaShiftIndex() - 1
+                        )
+                        a = np.memmap(
+                            f,
+                            dtype="int32",
+                            mode="w+",
+                            offset=mm.tell(),
+                            shape=(len(nbOfNodesPerCell),),
+                        )
+                        a[:] = nbOfNodesPerCell.toNumPyArray()
+                        a.flush()
+                        mm.seek(mm.tell() + len(nbOfNodesPerCell) * 4)
+                        ids2 = mp.getNodalConnectivityIndex().buildComplement(
+                            mp.getNodalConnectivityIndex().back() + 1
+                        )
+                        c2 = mp.getNodalConnectivity()[ids2] + 1
+                        a = np.memmap(
+                            f,
+                            dtype="int32",
+                            mode="w+",
+                            offset=mm.tell(),
+                            shape=(len(c2),),
+                        )
+                        a[:] = c2.toNumPyArray()
+                        a.flush()
+                        mm.seek(mm.tell() + len(c2) * 4)
                         pass
-                    i+=nbelem
+                    i += nbelem
                     pass
                 pass
             pass
         pass
 
-    def __writeFieldsPart(self,mdfs):
+    def __writeFieldsPart(self, mdfs):
         if not mdfs:
             return ""
-        self._ze_top_dict={}
-        its,areForgottenTS=mdfs.getCommonIterations()
+        self._ze_top_dict = {}
+        its, areForgottenTS = mdfs.getCommonIterations()
         if areForgottenTS:
-            print(("WARNING : some iterations are NOT present in all fields ! Kept iterations are : %s !"%(str(its))))
+            print(
+                (
+                    "WARNING : some iterations are NOT present in all fields ! Kept iterations are : %s !"
+                    % (str(its))
+                )
+            )
             pass
-        TimeValues=""
+        TimeValues = ""
         for it in its:
-            TimeValues+="%s\n"%(str(mdfs[0][it].getTime()[-1]))
+            TimeValues += "%s\n" % (str(mdfs[0][it].getTime()[-1]))
             pass
-        dictVars={}
+        dictVars = {}
         for mdf in mdfs:
-            nbCompo=mdf.getNumberOfComponents()
+            nbCompo = mdf.getNumberOfComponents()
             if nbCompo not in self.dictCompo:
                 l = [x for x in self.dictCompo if x - nbCompo > 0]
-                if len(l)==0:
-                    print(("Field \"%s\" will be ignored because number of components (%i) is too big to be %s supported by case files !"%(mdf.getName(),nbCompo,str(list(self.dictCompo.keys())))))
+                if len(l) == 0:
+                    print(
+                        (
+                            'Field "%s" will be ignored because number of components (%i) is too big to be %s supported by case files !'
+                            % (mdf.getName(), nbCompo, str(list(self.dictCompo.keys())))
+                        )
+                    )
                     continue
                     pass
-                print(("WARNING : Field \"%s\" will have its number of components (%i) set to %i, in order to be supported by case files (must be in %s) !"%(mdf.getName(),nbCompo,l[0],str(list(self.dictCompo.keys())))))
-                nbCompo=l[0]
+                print(
+                    (
+                        'WARNING : Field "%s" will have its number of components (%i) set to %i, in order to be supported by case files (must be in %s) !'
+                        % (
+                            mdf.getName(),
+                            nbCompo,
+                            l[0],
+                            str(list(self.dictCompo.keys())),
+                        )
+                    )
+                )
+                nbCompo = l[0]
                 pass
             if nbCompo in dictVars:
                 dictVars[nbCompo].append(mdf)
                 pass
             else:
-                dictVars[nbCompo]=[mdf]
+                dictVars[nbCompo] = [mdf]
                 pass
             pass
         for mdf in mdfs:
-            nbCompo=mdf.getNumberOfComponents()
+            nbCompo = mdf.getNumberOfComponents()
             if nbCompo not in self.dictCompo:
                 l = [x for x in self.dictCompo if x - nbCompo > 0]
-                if len(l)==0:
-                    continue;
-                nbCompo=l[0]
+                if len(l) == 0:
+                    continue
+                nbCompo = l[0]
                 pass
-            for iii,it in enumerate(its):
-                ff=mdf[it]
-                isMultiDisc=len(ff.getTypesOfFieldAvailable())>1
+            for iii, it in enumerate(its):
+                ff = mdf[it]
+                isMultiDisc = len(ff.getTypesOfFieldAvailable()) > 1
                 for typ in ff.getTypesOfFieldAvailable():
-                    l=self._l[:] ; l[-1]="%s%s.%s"%(self._base_name_without_dir,str(iii).rjust(4,"0"),ff.getName())
+                    l = self._l[:]
+                    l[-1] = "%s%s.%s" % (
+                        self._base_name_without_dir,
+                        str(iii).rjust(4, "0"),
+                        ff.getName(),
+                    )
                     if isMultiDisc:
-                        l[-1]="%s_%s"(l[-1],MEDCouplingFieldDiscretization.New(typ).getStringRepr())
+                        l[-1] = "%s_%s"(
+                            l[-1],
+                            MEDCouplingFieldDiscretization.New(typ).getStringRepr(),
+                        )
                         pass
-                    fffn=l[-1]
+                    fffn = l[-1]
                     try:
                         os.remove(os.path.sep.join(l))
                     except:
                         pass
-                    f=open(os.path.sep.join(l),"w+b")
-                    summ=0
-                    for geo,[(curTyp,(bg,end),pfl,loc)] in ff.getFieldSplitedByType():
-                        if typ==curTyp:
-                            summ+=4*nbCompo*(end-bg)+80
+                    f = open(os.path.sep.join(l), "w+b")
+                    summ = 0
+                    for geo, [
+                        (curTyp, (bg, end), pfl, loc)
+                    ] in ff.getFieldSplitedByType():
+                        if typ == curTyp:
+                            summ += 4 * nbCompo * (end - bg) + 80
                             pass
                         pass
-                    a=np.memmap(f,dtype='byte',mode='w+',offset=0,shape=(2*80+4+summ,)) ; a.flush() # truncate to set the size of the file
-                    mm=mmap.mmap(f.fileno(),offset=0,length=0)
-                    k1=ff.getName()
+                    a = np.memmap(
+                        f, dtype="byte", mode="w+", offset=0, shape=(2 * 80 + 4 + summ,)
+                    )
+                    a.flush()  # truncate to set the size of the file
+                    mm = mmap.mmap(f.fileno(), offset=0, length=0)
+                    k1 = ff.getName()
                     if isMultiDisc:
-                        k1="%s_%s"%(k1,MEDCouplingFieldDiscretization.New(typ).getStringRepr())
+                        k1 = "%s_%s" % (
+                            k1,
+                            MEDCouplingFieldDiscretization.New(typ).getStringRepr(),
+                        )
                         pass
                     mm.write(self.__str80(k1))
                     mm.write(self.__str80("part"))
-                    a=np.memmap(f,dtype='int32',mode='w+',offset=mm.tell(),shape=(1,))
-                    a[0]=1 ; a.flush() ; mm.seek(mm.tell()+4) # part number maybe to change ?
-                    for geo,[(curTyp,(bg,end),pfl,loc)] in ff.getFieldSplitedByType():
-                        if pfl!="":
-                            raise Exception("Field \"%s\" contains profiles ! Profiles are not supported yet !"%(mdf.getName()))
-                        if typ==curTyp:
-                            arr=ff.getUndergroundDataArray()[bg:end].changeNbOfComponents(nbCompo,0.) ; arr=arr.toNoInterlace()
-                            if typ==ON_CELLS:
+                    a = np.memmap(
+                        f, dtype="int32", mode="w+", offset=mm.tell(), shape=(1,)
+                    )
+                    a[0] = 1
+                    a.flush()
+                    mm.seek(mm.tell() + 4)  # part number maybe to change ?
+                    for geo, [
+                        (curTyp, (bg, end), pfl, loc)
+                    ] in ff.getFieldSplitedByType():
+                        if pfl != "":
+                            raise Exception(
+                                'Field "%s" contains profiles ! Profiles are not supported yet !'
+                                % (mdf.getName())
+                            )
+                        if typ == curTyp:
+                            arr = ff.getUndergroundDataArray()[
+                                bg:end
+                            ].changeNbOfComponents(nbCompo, 0.0)
+                            arr = arr.toNoInterlace()
+                            if typ == ON_CELLS:
                                 mm.write(self.__str80(self.dictMCTyp_str[geo]))
                                 pass
-                            elif typ==ON_NODES:
+                            elif typ == ON_NODES:
                                 mm.write(self.__str80("coordinates"))
                                 pass
                             else:
-                                print(("UnManaged type of field for field \"%s\" !"%(mdf.getName())))
+                                print(
+                                    (
+                                        'UnManaged type of field for field "%s" !'
+                                        % (mdf.getName())
+                                    )
+                                )
                                 pass
-                            a=np.memmap(f,dtype='float32',mode='w+',offset=mm.tell(),shape=(nbCompo,end-bg))
-                            b=arr.toNumPyArray() ; b=b.reshape(nbCompo,end-bg)
-                            a[:]=b
-                            a.flush() ; mm.seek(mm.tell()+nbCompo*(end-bg)*4)
+                            a = np.memmap(
+                                f,
+                                dtype="float32",
+                                mode="w+",
+                                offset=mm.tell(),
+                                shape=(nbCompo, end - bg),
+                            )
+                            b = arr.toNumPyArray()
+                            b = b.reshape(nbCompo, end - bg)
+                            a[:] = b
+                            a.flush()
+                            mm.seek(mm.tell() + nbCompo * (end - bg) * 4)
                             pass
                         pass
-                    k="%s per %s"%(self.dictCompo[nbCompo],self.discSpatial[typ])
+                    k = "%s per %s" % (self.dictCompo[nbCompo], self.discSpatial[typ])
                     if k in self._ze_top_dict:
                         if k1 in self._ze_top_dict[k]:
                             self._ze_top_dict[k][k1].append(fffn)
                             pass
                         else:
-                            self._ze_top_dict[k][k1]=[fffn]
+                            self._ze_top_dict[k][k1] = [fffn]
                             pass
                     else:
-                        self._ze_top_dict[k]={k1:[fffn]}
+                        self._ze_top_dict[k] = {k1: [fffn]}
                         pass
                     pass
                 pass
             pass
-        headerPart=""
-        if len(self._ze_top_dict)!=0:
-            hvp=self.header_varpart[:]
+        headerPart = ""
+        if len(self._ze_top_dict) != 0:
+            hvp = self.header_varpart[:]
             for k in self._ze_top_dict:
                 for k1 in self._ze_top_dict[k]:
-                    hvp+="\n%s: %s %s"%(k,k1,re.sub("([\d]{4})",4*"*",self._ze_top_dict[k][k1][0]))
+                    hvp += "\n%s: %s %s" % (
+                        k,
+                        k1,
+                        re.sub("([\d]{4})", 4 * "*", self._ze_top_dict[k][k1][0]),
+                    )
                     pass
                 pass
-            hvp+="\n"
-            headerPart+=hvp
+            hvp += "\n"
+            headerPart += hvp
             #
-            ddd={"NbTimeSteps":len(its),"TimeValues":TimeValues}
-            htp=self.header_timepart%ddd
-            headerPart+=htp
+            ddd = {"NbTimeSteps": len(its), "TimeValues": TimeValues}
+            htp = self.header_timepart % ddd
+            headerPart += htp
             pass
         return headerPart
 
     @classmethod
-    def __str80(cls,st):
-        if len(st)>79:
-            raise Exception("String \"%s\" is too long (>79) !"%(st))
-        return bytes(str(st).ljust(79)+"\n", "ascii")
+    def __str80(cls, st):
+        if len(st) > 79:
+            raise Exception('String "%s" is too long (>79) !' % (st))
+        return bytes(str(st).ljust(79) + "\n", "ascii")
 
-    def __computeSizeOfGeoFile(self,listOfMeshes,nn):
-        sz=0
+    def __computeSizeOfGeoFile(self, listOfMeshes, nn):
+        sz = 0
         for m in listOfMeshes:
-            distribTypes=m.getDistributionOfTypes()
-            sz+=80+4+2*80+4+nn*3*4
-            i=0
-            for typ2,nbelem,dummy in distribTypes:
-                typ=typ2
+            distribTypes = m.getDistributionOfTypes()
+            sz += 80 + 4 + 2 * 80 + 4 + nn * 3 * 4
+            i = 0
+            for typ2, nbelem, dummy in distribTypes:
+                typ = typ2
                 if typ not in self.dictMCTyp:
-                    typ=MEDCouplingMesh.GetCorrespondingPolyType()
+                    typ = MEDCouplingMesh.GetCorrespondingPolyType()
                     pass
-                if typ!=NORM_POLYHED and typ!=NORM_POLYGON:
-                    sz+=80+4+MEDCouplingMesh.GetNumberOfNodesOfGeometricType(typ)*nbelem*4
+                if typ != NORM_POLYHED and typ != NORM_POLYGON:
+                    sz += (
+                        80
+                        + 4
+                        + MEDCouplingMesh.GetNumberOfNodesOfGeometricType(typ)
+                        * nbelem
+                        * 4
+                    )
                     pass
-                elif typ==NORM_POLYHED:
-                    mplh=m[i:i+nbelem] ; delta=len(mplh.getNodalConnectivity())+nbelem
-                    sz+=80+4+delta*4
+                elif typ == NORM_POLYHED:
+                    mplh = m[i : i + nbelem]
+                    delta = len(mplh.getNodalConnectivity()) + nbelem
+                    sz += 80 + 4 + delta * 4
                     pass
                 else:
-                    mplh=m[i:i+nbelem] ; delta=len(mplh.getNodalConnectivity())
-                    sz+=80+4+delta*4
+                    mplh = m[i : i + nbelem]
+                    delta = len(mplh.getNodalConnectivity())
+                    sz += 80 + 4 + delta * 4
                     pass
-                i+=nbelem
+                i += nbelem
                 pass
             pass
         return sz