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: 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: 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 DictProxy(dict):
195 """A class that acts like a dictionary, but preserves the order 196 of the entries. Used to beautify the output""" 197
198 - def __init__(self):
199 dict.__init__(self) 200 self._order=[] 201 self._decoration={} 202 self._regex=[]
203
204 - def __setitem__(self,key,value):
205 isRegex=False 206 if type(key)==str: 207 if key[0]=='"' and key[-1]=='"': 208 isRegex=True 209 if isRegex: 210 exp=re.compile(key[1:-1]) 211 self._regex=[(key,exp,value)]+self._regex 212 else: 213 dict.__setitem__(self,key,value) 214 if key not in self._order or isRegex: 215 self._order.append(key)
216
217 - def __getitem__(self,key):
218 try: 219 return dict.__getitem__(self,key) 220 except KeyError: 221 for k,e,v in self._regex: 222 if e.match(key): 223 return v 224 raise KeyError(key)
225
226 - def __delitem__(self,key):
227 dict.__delitem__(self,key) 228 self._order.remove(key) 229 if key in self._decoration: 230 del self._decoration[key]
231
232 - def __deepcopy__(self,memo):
233 new=DictProxy() 234 for k in self._order: 235 try: 236 new[k]=deepcopy(self[k],memo) 237 except KeyError: 238 new[k]=deepcopy(self.getRegexpValue(k),memo) 239 240 return new
241
242 - def __contains__(self,key):
243 if dict.__contains__(self,key): 244 return True 245 else: 246 for k,e,v in self._regex: 247 if e.match(key): 248 return True 249 return False
250
251 - def addDecoration(self,key,text):
252 if key in self: 253 self._decoration[key]=text
254
255 - def getDecoration(self,key):
256 if key in self._decoration: 257 return " \t"+self._decoration[key] 258 else: 259 return ""
260
261 - def getRegexpValue(self,key):
262 for k,e,v in self._regex: 263 if k==key: 264 return v 265 raise KeyError(key)
266
267 -class TupleProxy(list):
268 """Enables Tuples to be manipulated""" 269
270 - def __init__(self,tup=()):
271 list.__init__(self,tup)
272
273 -class Unparsed(object):
274 """A class that encapsulates an unparsed string""" 275
276 - def __init__(self,data):
277 self.data=data
278
279 - def __str__(self):
280 return self.data
281
282 -class UnparsedList(object):
283 """A class that encapsulates a list that was not parsed for 284 performance reasons""" 285
286 - def __init__(self,lngth,data):
287 self.data=data 288 self.length=lngth
289
290 - def __len__(self):
291 return self.length
292
293 - def __cmp__(self,other):
294 return cmp(self.data,other.data)
295