1 # -*- coding: iso-8859-1 -*-
2 # Copyright (C) 2007-2015 CEA/DEN, EDF R&D
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License, or (at your option) any later version.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 # Author : Anthony GEAY (CEA/DEN/DM2S/STMF)
22 from MEDLoader import *
26 def New(cls,fileName):
27 """ Static constructor. """
28 return PVDReader(fileName)
31 def __init__(self,fileName):
32 self._fileName=fileName
35 def loadTopInfo(self):
36 fd=open(self._fileName,"r")
37 return self.__parseXML(fd)
39 def __parseXML(self,fd):
41 class PVD_SAX_Reader(xml.sax.ContentHandler):
45 def startElement(self,name,attrs):
47 if attrs["type"]!="Collection":
48 raise Exception("Mismatch between reader (PVD) type and file content !")
51 self._tsteps.append((float(attrs["timestep"]),str(attrs["file"])))
56 parser=xml.sax.make_parser()
57 parser.setContentHandler(rd)
64 def New(cls,fileName):
65 """ Static constructor. """
66 return PVTUReader(fileName)
69 def __init__(self,fileName):
70 self._fileName=fileName
73 def loadParaInfo(self):
74 fd=open(self._fileName,"r")
75 return self.__parseXML(fd)
77 def __parseXML(self,fd):
79 class PVTU_SAX_Reader(xml.sax.ContentHandler):
81 self._data_array={2:self.DAPointData,3:self.DACellData}
87 def DAPointData(self,attrs):
88 self._node_fields.append((str(attrs["Name"]),int(attrs["NumberOfComponents"])))
90 def DACellData(self,attrs):
91 self._cell_fields.append((str(attrs["Name"]),int(attrs["NumberOfComponents"])))
93 def startElement(self,name,attrs):
95 if attrs["type"]!="PUnstructuredGrid":
96 raise Exception("Mismatch between reader (PVTU) type and file content !")
99 self._pfiles.append(str(attrs["Source"]))
101 if name=="PPointData":
104 if name=="PCellData":
107 if name=="PDataArray":
108 if self._tmp in self._data_array.keys():
109 self._data_array[self._tmp](attrs)
115 parser=xml.sax.make_parser()
116 parser.setContentHandler(rd)
122 """ Converting a VTU file in raw mode into the MED format.
124 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]
126 class NormalException(Exception):
129 class NotRawVTUException(Exception):
132 def loadInMEDFileDS(self):
134 fd=open(self._fileName,"r")
135 ref,rd=self.__parseXML(fd)
138 ms=MEDFileMeshes() ; ret.setMeshes(ms)
139 fs=MEDFileFields() ; ret.setFields(fs)
141 types=np.memmap(fd,dtype=rd._type_types,mode='r',offset=ref+rd._off_types,shape=(rd._nb_cells,))
142 types=self.__swapIfNecessary(rd._bo,types)
143 # mesh dimension detection
144 types2=types.copy() ; types2.sort() ; types2=np.unique(types2)
145 meshDim=MEDCouplingMesh.GetDimensionOfGeometricType(self.VTKTypes_2_MC[types2[0]])
146 for typ in types2[1:]:
147 md=MEDCouplingMesh.GetDimensionOfGeometricType(self.VTKTypes_2_MC[typ])
149 raise Exception("MultiLevel umeshes not managed yet !")
151 m=MEDCouplingUMesh("mesh",meshDim)
153 coo=np.memmap(fd,dtype=rd._type_coords,mode='r',offset=ref+rd._off_coords,shape=(rd._nb_nodes*rd._space_dim,))
154 coo=self.__swapIfNecessary(rd._bo,coo) ; coo=DataArrayDouble(np.array(coo,dtype='float64')) ; coo.rearrange(rd._space_dim)
157 offsets=np.memmap(fd,dtype=rd._type_off,mode='r',offset=ref+rd._off_off,shape=(rd._nb_cells,))
158 offsets=self.__swapIfNecessary(rd._bo,offsets) ; connLgth=offsets[-1] ; offsets2=DataArrayInt(rd._nb_cells+1) ; offsets2.setIJ(0,0,0)
159 offsets2[1:]=DataArrayInt(offsets)
160 offsets3=offsets2.deltaShiftIndex() ; offsets2=offsets3.deepCpy() ; offsets3+=1 ; offsets3.computeOffsets2()
162 tmp1=DataArrayInt(len(offsets2),2) ; tmp1[:,0]=1 ; tmp1[:,1]=offsets2 ; tmp1.rearrange(1) ; tmp1.computeOffsets2()
163 tmp1=DataArrayInt.Range(1,2*len(offsets2),2).buildExplicitArrByRanges(tmp1)
164 conn=np.memmap(fd,dtype=rd._type_conn,mode='r',offset=ref+rd._off_conn,shape=(connLgth,))
165 conn=self.__swapIfNecessary(rd._bo,conn)
166 types=np.array(types,dtype='int32') ; types=DataArrayInt(types) ; types.transformWithIndArr(self.VTKTypes_2_MC)
167 conn2=DataArrayInt(offsets.back())
168 conn2[offsets[0:-1]]=types
169 conn2[tmp1]=DataArrayInt(conn)
170 m.setConnectivity(conn2,offsets,True)
171 m.checkCoherency() ; mm=MEDFileUMesh() ; mm.setMeshAtLevel(0,m) ; ms.pushMesh(mm)
172 # Fields on nodes and on cells
173 for spatialDisc,nbEnt,fields in [(ON_NODES,rd._nb_nodes,rd._node_fields),(ON_CELLS,rd._nb_cells,rd._cell_fields)]:
174 for name,typ,nbCompo,off in fields:
175 ff=MEDFileFieldMultiTS()
176 f=MEDCouplingFieldDouble(spatialDisc,ONE_TIME)
177 f.setName(name) ; f.setMesh(m)
178 vals=np.memmap(fd,dtype=typ,mode='r',offset=ref+off,shape=(nbEnt*nbCompo))
179 vals=self.__swapIfNecessary(rd._bo,vals)
180 arr=DataArrayDouble(np.array(vals,dtype='float64')) ; arr.rearrange(nbCompo)
181 f.setArray(arr) ; f.checkCoherency()
182 f.setTime(self._time[0],self._time[1],0)
183 ff.appendFieldNoProfileSBT(f)
189 def __parseXML(self,fd):
191 class VTU_SAX_Reader(xml.sax.ContentHandler):
193 self._data_array={0:self.DAPoints,1:self.DACells,2:self.DAPointData,3:self.DACellData}
197 def DAPoints(self,attrs):
198 self._space_dim=int(attrs["NumberOfComponents"])
199 self._type_coords=str(attrs["type"]).lower()
200 self._off_coords=int(attrs["offset"])
202 def DACells(self,attrs):
203 if attrs["Name"]=="connectivity":
204 self._type_conn=str(attrs["type"]).lower()
205 self._off_conn=int(attrs["offset"])
207 if attrs["Name"]=="offsets":
208 self._type_off=str(attrs["type"]).lower()
209 self._off_off=int(attrs["offset"])
211 if attrs["Name"]=="types":
212 self._type_types=str(attrs["type"]).lower()
213 self._off_types=int(attrs["offset"])
216 def DAPointData(self,attrs):
217 self._node_fields.append((str(attrs["Name"]),str(attrs["type"]).lower(),int(attrs["NumberOfComponents"]),int(attrs["offset"])))
219 def DACellData(self,attrs):
220 self._cell_fields.append((str(attrs["Name"]),str(attrs["type"]).lower(),int(attrs["NumberOfComponents"]),int(attrs["offset"])))
222 def startElement(self,name,attrs):
224 if attrs["type"]!="UnstructuredGrid":
225 raise Exception("Mismatch between reader (VTU) type and file content !")
226 self._bo=bool(["LittleEndian","BigEndian"].index(attrs["byte_order"]))
229 self._nb_cells=int(attrs["NumberOfCells"])
230 self._nb_nodes=int(attrs["NumberOfPoints"])
238 if name=="PointData":
244 if name=="DataArray":
245 self._data_array[self._tmp](attrs)
247 if name=="AppendedData":
248 if str(attrs["encoding"])=="raw":
249 raise VTURawReader.NormalException("")
251 raise VTURawReader.NotRawVTUException("The file is not a raw VTU ! Change reader !")
255 parser=xml.sax.make_parser()
256 parser.setContentHandler(rd)
260 except self.NormalException as e:
263 for i in xrange(31): fd.readline()
267 raise Exception("Error in VTURawReader : not a raw format ?")
271 def New(cls,fileName,tim=(0.,0)):
272 """ Static constructor. """
273 return VTURawReader(fileName,tim)
276 def __init__(self,fileName,tim=(0.,0)):
277 msg="The time specified in constructor as 2nd arg should be a tuple containing 2 values 1 float and 1 int !"
282 if type(tim[0])!=float or type(tim[1])!=int:
284 self._fileName=fileName
288 def __swapIfNecessary(self,b,arr):