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
10 return "'"+str(self)+"'"
11
12
13 -class Field(FoamDataType):
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
30
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
42 assert(not self.uniform)
43 return self.val[key]
44
46 assert(not self.uniform)
47 self.val[key]=value
48
51
54
59
62 assert(len(dims)==7)
63 self.dims=list(dims)
64
66 result="[ "
67 for v in self.dims:
68 result+=str(v)+" "
69 result+="]"
70 return result
71
73 if other==None:
74 return 1
75 return cmp(self.dims,other.dims)
76
79
82
86
88 return "("+string.join(map(lambda v:"%g"%v,self.vals))+")"
89
91 if other==None or not issubclass(type(other),FixedLength):
92 return 1
93 return cmp(self.vals,other.vals)
94
97
100
102 return len(self.vals)
103
107
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
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
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
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
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
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
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
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
175 x=self
176 return math.sqrt(x[0]*x[0]+x[1]*x[1]+x[2]*x[2])
177
179 x=self
180 return Vector(-x[0],-x[1],-x[2])
181
183 x=self
184 return Vector( x[0], x[1], x[2])
185
187 - def __init__(self,v1,v2,v3,v4,v5,v6,v7,v8,v9):
189
193
195 """A class that acts like a dictionary, but preserves the order
196 of the entries. Used to beautify the output"""
197
199 dict.__init__(self)
200 self._order=[]
201 self._decoration={}
202 self._regex=[]
203
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
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
227 dict.__delitem__(self,key)
228 self._order.remove(key)
229 if key in self._decoration:
230 del self._decoration[key]
231
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
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
252 return self._order[:]
253
255 if key in self:
256 if key not in self._decoration:
257 self._decoration[key]=""
258 self._decoration[key]+=text
259
261 if key in self._decoration:
262 return " \t"+self._decoration[key]
263 else:
264 return ""
265
267 for k,e,v in self._regex:
268 if k==key:
269 return v
270 raise KeyError(key)
271
273 """Enables Tuples to be manipulated"""
274
277
279 """A class that encapsulates an unparsed string"""
280
283
286
288 """A class that encapsulates an codestream string"""
289
292
294 return "#{" + self.data + "#}"
295
297 """A class that encapsulates a list that was not parsed for
298 performance reasons"""
299
301 self.data=data
302 self.length=lngth
303
306
308 return cmp(self.data,other.data)
309