Package PyFoam :: Package Basics :: Module DataStructures
[hide private]
[frames] | no frames]

Source Code for Module PyFoam.Basics.DataStructures

  1  """Data structures in Foam-Files that can't be directly represented by Python-Structures""" 
  2   
  3  import FoamFileGenerator 
  4  from copy import deepcopy 
  5  import string,math 
  6  import re 
  7   
8 -class FoamDataType(object):
9 - def __repr__(self):
10 return "'"+str(self)+"'"
11 12
13 -class Field(FoamDataType):
14 - def __init__(self,val,name=None):
15 self.val=val 16 self.name=name 17 if self.name==None: 18 self.uniform=True 19 elif type(val) in[list,UnparsedList]: 20 self.uniform=False
21
22 - def __str__(self):
23 result="" 24 if self.uniform: 25 result+="uniform " 26 else: 27 result+="nonuniform "+self.name+" " 28 result+=str(FoamFileGenerator.FoamFileGenerator(self.val)) 29 return result
30
31 - def __cmp__(self,other):
32 if other==None or type(other)!=Field: 33 return 1 34 if self.uniform!=other.uniform: 35 return cmp(self.uniform,other.uniform) 36 elif self.name!=other.name: 37 return cmp(self.name,other.name) 38 else: 39 return cmp(self.val,other.val)
40
41 - def __getitem__(self,key):
42 assert(not self.uniform) 43 return self.val[key]
44
45 - def __setitem__(self,key,value):
46 assert(not self.uniform) 47 self.val[key]=value
48
49 - def isUniform(self):
50 return self.uniform
51
52 - def value(self):
53 return self.val
54
55 - def setUniform(self,data):
56 self.val=data 57 self.uniform=True 58 self.name=None
59
60 -class Dimension(FoamDataType):
61 - def __init__(self,*dims):
62 assert(len(dims)==7) 63 self.dims=list(dims)
64
65 - def __str__(self):
66 result="[ " 67 for v in self.dims: 68 result+=str(v)+" " 69 result+="]" 70 return result
71
72 - def __cmp__(self,other):
73 if other==None: 74 return 1 75 return cmp(self.dims,other.dims)
76
77 - def __getitem__(self,key):
78 return self.dims[key]
79
80 - def __setitem__(self,key,value):
81 self.dims[key]=value
82
83 -class FixedLength(FoamDataType):
84 - def __init__(self,vals):
85 self.vals=vals[:]
86
87 - def __str__(self):
88 return "("+string.join(map(lambda v:"%g"%v,self.vals))+")"
89
90 - def __cmp__(self,other):
91 if other==None or not issubclass(type(other),FixedLength): 92 return 1 93 return cmp(self.vals,other.vals)
94
95 - def __getitem__(self,key):
96 return self.vals[key]
97
98 - def __setitem__(self,key,value):
99 self.vals[key]=value
100
101 - def __len__(self):
102 return len(self.vals)
103
104 -class Vector(FixedLength):
105 - def __init__(self,x,y,z):
106 FixedLength.__init__(self,[x,y,z])
107
108 - def __add__(self,y):
109 x=self 110 if type(y)==Vector: 111 return Vector(x[0]+y[0],x[1]+y[1],x[2]+y[2]) 112 elif type(y) in [int,float,long]: 113 return Vector(x[0]+y,x[1]+y,x[2]+y) 114 else: 115 return NotImplemented
116
117 - def __radd__(self,y):
118 x=self 119 if type(y) in [int,float,long]: 120 return Vector(x[0]+y,x[1]+y,x[2]+y) 121 else: 122 return NotImplemented
123
124 - def __sub__(self,y):
125 x=self 126 if type(y)==Vector: 127 return Vector(x[0]-y[0],x[1]-y[1],x[2]-y[2]) 128 elif type(y) in [int,float,long]: 129 return Vector(x[0]-y,x[1]-y,x[2]-y) 130 else: 131 return NotImplemented
132
133 - def __rsub__(self,y):
134 x=self 135 if type(y) in [int,float,long]: 136 return Vector(y-x[0],y-x[1],y-x[2]) 137 else: 138 return NotImplemented
139
140 - def __mul__(self,y):
141 x=self 142 if type(y)==Vector: 143 return Vector(x[0]*y[0],x[1]*y[1],x[2]*y[2]) 144 elif type(y) in [int,float,long]: 145 return Vector(x[0]*y,x[1]*y,x[2]*y) 146 else: 147 return NotImplemented
148
149 - def __rmul__(self,y):
150 x=self 151 if type(y) in [int,float,long]: 152 return Vector(y*x[0],y*x[1],y*x[2]) 153 else: 154 return NotImplemented
155
156 - def __div__(self,y):
157 x=self 158 if type(y)==Vector: 159 return Vector(x[0]/y[0],x[1]/y[1],x[2]/y[2]) 160 elif type(y) in [int,float,long]: 161 return Vector(x[0]/y,x[1]/y,x[2]/y) 162 else: 163 return NotImplemented
164
165 - def __xor__(self,y):
166 x=self 167 if type(y)==Vector: 168 return Vector(x[1]*y[2]-x[2]*y[1], 169 x[2]*y[0]-x[0]*y[2], 170 x[0]*y[1]-x[1]*y[0]) 171 else: 172 return NotImplemented
173
174 - def __abs__(self):
175 x=self 176 return math.sqrt(x[0]*x[0]+x[1]*x[1]+x[2]*x[2])
177
178 - def __neg__(self):
179 x=self 180 return Vector(-x[0],-x[1],-x[2])
181
182 - def __pos__(self):
183 x=self 184 return Vector( x[0], x[1], x[2])
185
186 -class Tensor(FixedLength):
187 - def __init__(self,v1,v2,v3,v4,v5,v6,v7,v8,v9):
188 FixedLength.__init__(self,[v1,v2,v3,v4,v5,v6,v7,v8,v9])
189
190 -class SymmTensor(FixedLength):
191 - def __init__(self,v1,v2,v3,v4,v5,v6):
192 FixedLength.__init__(self,[v1,v2,v3,v4,v5,v6])
193
194 -class DictRedirection(object):
195 """This class is in charge of handling redirections to other directories"""
196 - def __init__(self,fullCopy,reference,name):
197 self._fullCopy=fullCopy 198 self._reference=reference 199 self._name=name
200
201 - def useAsRedirect(self):
202 self._fullCopy=None
203
204 - def getContent(self):
205 result=self._fullCopy 206 self._fullCopy=None 207 return result
208
209 - def __call__(self):
210 return self._reference
211
212 - def __str__(self):
213 return "$"+self._name
214
215 -class DictProxy(dict):
216 """A class that acts like a dictionary, but preserves the order 217 of the entries. Used to beautify the output""" 218
219 - def __init__(self):
220 dict.__init__(self) 221 self._order=[] 222 self._decoration={} 223 self._regex=[] 224 self._redirects=[]
225
226 - def __setitem__(self,key,value):
227 isRegex=False 228 if type(key)==str: 229 if key[0]=='"' and key[-1]=='"': 230 isRegex=True 231 if isRegex: 232 exp=re.compile(key[1:-1]) 233 self._regex=[(key,exp,value)]+self._regex 234 else: 235 dict.__setitem__(self,key,value) 236 if key not in self._order or isRegex: 237 self._order.append(key)
238
239 - def __getitem__(self,key):
240 try: 241 return dict.__getitem__(self,key) 242 except KeyError: 243 for k,e,v in self._regex: 244 if e.match(key): 245 return v 246 for r in self._redirects: 247 try: 248 return r()[key] 249 except KeyError: 250 pass 251 252 raise KeyError(key)
253
254 - def __delitem__(self,key):
255 dict.__delitem__(self,key) 256 self._order.remove(key) 257 if key in self._decoration: 258 del self._decoration[key]
259
260 - def __deepcopy__(self,memo):
261 new=DictProxy() 262 for k in self._order: 263 if type(k)==DictRedirection: 264 new.addRedirection(k) 265 else: 266 try: 267 new[k]=deepcopy(self[k],memo) 268 except KeyError: 269 new[k]=deepcopy(self.getRegexpValue(k),memo) 270 271 return new
272
273 - def __contains__(self,key):
274 if dict.__contains__(self,key): 275 return True 276 else: 277 for k,e,v in self._regex: 278 if e.match(key): 279 return True 280 for r in self._redirects: 281 if key in r(): 282 return True 283 284 return False
285
286 - def keys(self):
287 return filter(lambda x:type(x)!=DictRedirection,self._order)
288
289 - def addDecoration(self,key,text):
290 if key in self: 291 if key not in self._decoration: 292 self._decoration[key]="" 293 self._decoration[key]+=text
294
295 - def getDecoration(self,key):
296 if key in self._decoration: 297 return " \t"+self._decoration[key] 298 else: 299 return ""
300
301 - def getRegexpValue(self,key):
302 for k,e,v in self._regex: 303 if k==key: 304 return v 305 raise KeyError(key)
306
307 - def addRedirection(self,redir):
308 self._order.append(redir) 309 redir.useAsRedirect() 310 self._redirects.append(redir)
311
312 -class TupleProxy(list):
313 """Enables Tuples to be manipulated""" 314
315 - def __init__(self,tup=()):
316 list.__init__(self,tup)
317
318 -class Unparsed(object):
319 """A class that encapsulates an unparsed string""" 320
321 - def __init__(self,data):
322 self.data=data
323
324 - def __str__(self):
325 return self.data
326
327 -class Codestream(str):
328 """A class that encapsulates an codestream string""" 329
330 - def __str__(self):
331 return "#{" + str.__str__(self) + "#}"
332
333 -class UnparsedList(object):
334 """A class that encapsulates a list that was not parsed for 335 performance reasons""" 336
337 - def __init__(self,lngth,data):
338 self.data=data 339 self.length=lngth
340
341 - def __len__(self):
342 return self.length
343
344 - def __cmp__(self,other):
345 return cmp(self.data,other.data)
346