/[escript]/trunk/modellib/py_src/geometry.py
ViewVC logotype

Diff of /trunk/modellib/py_src/geometry.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/esys2/modellib/py_src/geometry.py revision 127 by jgs, Fri Jul 22 05:11:29 2005 UTC trunk/modellib/py_src/geometry.py revision 406 by gross, Fri Dec 23 00:39:59 2005 UTC
# Line 1  Line 1 
1  # $Id$  # $Id$
2    
3    
 from esys.modelframe import Model  
4  from esys.escript import *  from esys.escript import *
5  import esys.finley as finley  from esys.escript.modelframe import Model,ParameterSet
6    from esys import finley
7    
8  class RectangularDomain(Model):  class FinleyReader(ParameterSet):
9         """   """         """
10           Generates a mesh over a rectangular domain finley.
11    
12           @ivar filename:
13           @ivar intergrationOrder
14           @ivar domain:
15           """
16         def __init__(self,debug=False):         def __init__(self,debug=False):
17             Model.__init__(self,debug=debug)             super(FinleyReader,self).__init__(debug=debug)
18             self.declareParameter(domain=None, dim=2,\             ParameterSet.__init__(self,debug=debug)
19               self.declareParameter(source="none",\
20                                     integrationOrder=-1)
21               self._domain=None
22    
23           def domain(self):
24              if self._domain==None:
25                  self._domain=finley.ReadMesh(self.source,self.integrationOrder)
26                  self.trace("mesh read from %s"%self.source)          
27              return self._domain
28                          
29    class RectangularDomain(ParameterSet):
30           """
31           Generates a mesh over a rectangular domain finley.
32    
33           @ivar dim:
34           @ivar l:
35           @ivar n:
36           @ivar order:
37           @ivar periodic:
38           @ivar intergration order:
39           @ivar domain:
40           """
41           def __init__(self,debug=False):
42               super(RectangularDomain,self).__init__(debug=debug)
43               self.declareParameter(dim=2,\
44                                   l=[1.,1.,1.],\                                   l=[1.,1.,1.],\
45                                   n=[10,10,10], \                                   n=[10,10,10], \
46                   order=1,\                   order=1,\
47                                   periodic=[False,False,False],\                                   periodic=[False,False,False],\
48                                   integrationOrder=-1)                                   integrationOrder=-1)
49         def doInitialization(self,t):             self._domain=None
50            if self.dim==2:  
51               self.domain=finley.Rectangle(n0=self.n[0],\         def domain(self):
52                                            n1=self.n[1],\            if self._domain==None:
53                                            l0=self.l[0],\               if self.dim==2:
54                                            l1=self.l[1],\                  self._domain=finley.Rectangle(n0=self.n[0],\
55                                            order=self.order, \                                               n1=self.n[1],\
56                                            periodic0=self.periodic[0], \                                               l0=self.l[0],\
57                                            periodic1=self.periodic[1], \                                               l1=self.l[1],\
58                                            integrationOrder=self.integrationOrder)                                               order=self.order, \
59            else:                                               periodic0=self.periodic[0], \
60               self.domain=finley.Brick(n0=self.n[0],\                                               periodic1=self.periodic[1], \
61                                        n1=self.n[1],\                                               integrationOrder=self.integrationOrder)
62                                        n2=self.n[2],\               else:
63                                        l0=self.l[0],\                  self._domain=finley.Brick(n0=self.n[0],\
64                                        l1=self.l[1],\                                           n1=self.n[1],\
65                                        l2=self.l[2],\                                           n2=self.n[2],\
66                                        order=self.order, \                                           l0=self.l[0],\
67                                        periodic0=self.periodic[0], \                                           l1=self.l[1],\
68                                        periodic1=self.periodic[1], \                                           l2=self.l[2],\
69                                        periodic2=self.periodic[2], \                                           order=self.order, \
70                                        integrationOrder=self.integrationOrder)                                           periodic0=self.periodic[0], \
71                                             periodic1=self.periodic[1], \
72  class ScalarConstrainer(Model):                                           periodic2=self.periodic[2], \
73       """@brief creates a characteristic function for the location of constraints for a scalar value                                           integrationOrder=self.integrationOrder)
74    
75                @param domain (in) - rectangular domain            return self._domain
76                @param left (in)  - True to set a constraint at the left face of the domain (x[0]=min x[0]), default is False  
77                @param right (in) - True to set a constraint at the left face of the domain (x[0]=max x[0]), default is False  class ConstrainValue(Model):
78                @param top (in)  - True to set a constraint at the left face of the domain (x[1]=min x[1]), default is False         """
79                @param bottom (in) - True to set a constraint at the left face of the domain (x[1]=max x[1]), default is False         selects values for a given distribution to be used as a constrain. the location of the
80                @param front (in)  - True to set a constraint at the left face of the domain (x[2]=min x[2]), default is False         constrain are he faces of a rectangular domain. This Model is typically used in
81                @param back (in) - True to set a constraint at the left face of the domain (x[2]=max x[2]), default is False         time dependend problems to fix the values in a given initial condition.
82                @param location_of_constraint (out) - object that defines the location of the constraints.         """
83           def __init__(self,debug=False):
84               Model.__init__(self,debug=debug)
85               self.declareParameter(domain=None, \
86                                     value=0,  \
87                                     top=True,  \
88                                     bottom=True,\
89                                     front=False, \
90                                     back=False,\
91                                     left=False,\
92                                     right=False,\
93                                     constrain_value = None,  \
94                                     location_constrained_value=None)
95           def doInitialization(self):
96               """
97               initialize time stepping
98               """
99               x=self.domain.getX()
100               d=self.domain.getDim()
101               self.location_constrained_value=0
102               x0=x[0]
103               if self.left:
104                   self.location_constrained_value=self.location_constrained_value+whereZero(x0-inf(x0))
105               if self.right:
106                   self.location_constrained_value=self.location_constrained_value+whereZero(x0-sup(x0))
107               x0=x[d-1]
108               if self.buttom:
109                   self.location_constrained_value=self.location_constrained_value+whereZero(x0-inf(x0))
110               if self.top:
111                   self.location_constrained_value=self.location_constrained_value+whereZero(x0-sup(x0))
112               if d>2:
113                  x0=x[1]
114                  if self.front:
115                     self.location_constrained_value=self.location_constrained_value+whereZero(x0-inf(x0))
116                  if self.back:
117                     self.location_constrained_value=self.location_constrained_value+whereZero(x0-sup(x0))          
118               self.constrain_value=self.value*self.location_constrained_value
119              
120    class ScalarConstrainer(ParameterSet):
121         """
122         Creates a characteristic function for the location of constraints
123         for a scalar value.
124    
125         In the case that the spatial dimension is two, teh arguments front and back are ignored       In the case that the spatial dimension is two, the arguments front
126         and back are ignored.
127    
128         @ivar domain (in): rectangular domain
129         @ivar left (in): True to set a constraint at the left face of the
130                   domain (x[0]=min x[0]), default is False
131         @ivar right (in): True to set a constraint at the left face of the
132                   domain (x[0]=max x[0]), default is False
133         @ivar top (in): True to set a constraint at the left face of the
134                   domain (x[1]=min x[1]), default is False
135         @ivar bottom (in): True to set a constraint at the left face of the
136                   domain (x[1]=max x[1]), default is False
137         @ivar front (in): True to set a constraint at the left face of the
138                   domain (x[2]=min x[2]), default is False
139         @ivar back (in): True to set a constraint at the left face of the
140                   domain (x[2]=max x[2]), default is False
141         @ivar location_of_constraint (out): object that defines the location
142                   of the constraints.
143       """       """
144       def __init__(self,debug=False):       def __init__(self,debug=False):
145             Model.__init__(self,debug=debug)             ParameterSet.__init__(self,debug=debug)
146             self.declareParameter(domain=None, \             self.declareParameter(domain=None, \
147                                   left=False,                                   left=False, \
148                                   right=False,                                   right=False, \
149                                   top=False,                                   top=False, \
150                                   bottom=False,                                   bottom=False, \
151                                   front=False,                                   front=False, \
152                                   back=False,                                   back=False)
153                                   location_of_constraint=Data())             self._location_of_constraint=None
154       def doInitialization(self,t):  
155            x=self.domain.getX()       def location_of_constraint(self):
156            self.location_of_constraint=Scalar(0,x.getFunctionSpace())            """
157            if self.domain.getDim()==3:            Returns the mask of the location of constraint.
158               if self.left: self.location_of_constraint+=(x[0]-inf(x[0])).whereZero()            """
159               if self.right: self.location_of_constraint+=(x[0]-sup(x[0])).whereZero()            if self._location_of_constraint==None:
160               if self.front: self.location_of_constraint+=(x[1]-inf(x[1])).whereZero()               x=self.domain.getX()
161               if self.back: self.location_of_constraint+=(x[1]-sup(x[1])).whereZero()               self._location_of_constraint=Scalar(0,x.getFunctionSpace())
162               if self.bottom: self.location_of_constraint+=(x[2]-inf(x[2])).whereZero()               if self.domain.getDim()==3:
163               if self.top: self.location_of_constraint+=(x[2]-sup(x[2])).whereZero()                  if self.left: self._location_of_constraint+=whereZero(x[0]-inf(x[0]))
164            else:                  if self.right: self._location_of_constraint+=whereZero(x[0]-sup(x[0]))
165               if self.left: self.location_of_constraint+=(x[0]-inf(x[0])).whereZero()                  if self.front: self._location_of_constraint+=whereZero(x[1]-inf(x[1]))
166               if self.right: self.location_of_constraint+=(x[0]-sup(x[0])).whereZero()                  if self.back: self._location_of_constraint+=whereZero(x[1]-sup(x[1]))
167               if self.bottom: self.location_of_constraint+=(x[1]-inf(x[1])).whereZero()                  if self.bottom: self._location_of_constraint+=whereZero(x[2]-inf(x[2]))
168               if self.top: self.location_of_constraint+=(x[1]-sup(x[1])).whereZero()                  if self.top: self._location_of_constraint+=whereZero(x[2]-sup(x[2]))
169                 else:
170  class VectorConstrainer(Model):                  if self.left: self._location_of_constraint+=whereZero(x[0]-inf(x[0]))
171        """@brief creates a characteristic function for the location of constraints for a scalar value                  if self.right: self._location_of_constraint+=whereZero(x[0]-sup(x[0]))
172                    if self.bottom: self._location_of_constraint+=whereZero(x[1]-inf(x[1]))
173                @param domain (in) - rectangular domain                  if self.top: self._location_of_constraint+=whereZero(x[1]-sup(x[1]))
174                @param left (in)  - list of three boolean. left[i]==True sets a constraint for the i-th component at the left            return self._location_of_constraint
                                   face of the domain (x[0]=min x[0]), default is [False,False,False]  
               @param right (in) - list of three boolean. left[i]==True sets a constraint for the i-th component at the right  
                                   face of the domain (x[0]=max x[0]), default is [False,False,False]  
               @param top (in)  - list of three boolean. left[i]==True sets a constraint for the i-th component at the top  
                                   face of the domain (x[1]=min x[1]), default is [False,False,False]  
               @param bottom (in) - list of three boolean. left[i]==True sets a constraint for the i-th component at the bottom  
                                   face of the domain (x[1]=min x[1]), default is [False,False,False]  
               @param front (in)  - list of three boolean. left[i]==True sets a constraint for the i-th component at the front  
                                   face of the domain (x[2]=min x[2]), default is [False,False,False]  
               @param back (in) - list of three boolean. left[i]==True sets a constraint for the i-th component at the back  
                                   face of the domain (x[2]=max x[2]), default is [False,False,False]  
               @param location_of_constraint (out) - object that defines the location of the constraints for each vector component.  
175    
176         In the case that the spatial dimension is two, thh arguments front and back as well as the third component of each argument is ignored.  class VectorConstrainer(ParameterSet):
177          """
178          Creates a characteristic function for the location of constraints
179          for a scalar value.
180    
181          @ivar domain (in): rectangular domain
182          @ivar left (in): list of three boolean. left[i]==True sets a
183                    constraint for the i-th component at the left
184                    face of the domain (x[0]=min x[0]),
185                    default is [False,False,False]
186          @ivar right (in): list of three boolean. left[i]==True sets a
187                    constraint for the i-th component at the right
188                    face of the domain (x[0]=max x[0]),
189                    default is [False,False,False]
190          @ivar top (in): list of three boolean. left[i]==True sets a
191                    constraint for the i-th component at the top
192                    face of the domain (x[1]=min x[1]),
193                    default is [False,False,False]
194          @ivar bottom (in): list of three boolean. left[i]==True sets a
195                    constraint for the i-th component at the bottom
196                    face of the domain (x[1]=min x[1]),
197                    default is [False,False,False]
198          @ivar front (in): list of three boolean. left[i]==True sets a
199                    constraint for the i-th component at the front
200                    face of the domain (x[2]=min x[2]),
201                    default is [False,False,False]
202          @ivar back (in): list of three boolean. left[i]==True sets a
203                    constraint for the i-th component at the back
204                    face of the domain (x[2]=max x[2]),
205                    default is [False,False,False]
206          @ivar location_of_constraint (callable): object that defines the location of the constraints for each vector component.
207    
208          In the case that the spatial dimension is two, thh arguments front and
209          back as well as the third component of each argument is ignored.
210        """        """
211        def __init__(self,debug=False):        def __init__(self,debug=False):
212             Model.__init__(self,debug=debug)             ParameterSet.__init__(self,debug=debug)
213             self.declareParameter(domain=None, \             self.declareParameter(domain=None, \
214                                   left=[0,0,0],                                   left=[0,0,0],  \
215                                   right=[0,0,0],                                   right=[0,0,0],  \
216                                   top=[0,0,0],                                   top=[0,0,0],  \
217                                   bottom=[0,0,0],                                   bottom=[0,0,0],  \
218                                   front=[0,0,0],                                   front=[0,0,0],
219                                   back=[0,0,0],                                   back=[0,0,0])
220                                   location_of_constraint=Data())             self._location_of_constraint=None
221        def doInitialization(self,t):        def location_of_constraint(self):
222            x=self.domain.getX()            """
223            self.location_of_constraint=Vector(0,x.getFunctionSpace())            Returns the mask of the location of constraint.
224            if self.domain.getDim()==3:            """
225               left_mask=(x[0]-inf(x[0])).whereZero()            if self._location_of_constraint==None:
226               if self.left[0]: self.location_of_constraint+=left_mask*[1.,0.,0.]               x=self.domain.getX()
227               if self.left[1]: self.location_of_constraint+=left_mask*[0.,1.,0.]               self._location_of_constraint=Vector(0,x.getFunctionSpace())
228               if self.left[2]: self.location_of_constraint+=left_mask*[0.,0.,1.]               if self.domain.getDim()==3:
229               right_mask=(x[0]-inf(x[0])).whereZero()                  left_mask=whereZero(x[0]-inf(x[0]))
230               if self.right[0]: self.location_of_constraint+=right_mask*[1.,0.,0.]                  if self.left[0]: self._location_of_constraint+=left_mask*[1.,0.,0.]
231               if self.right[1]: self.location_of_constraint+=right_mask*[0.,1.,0.]                  if self.left[1]: self._location_of_constraint+=left_mask*[0.,1.,0.]
232               if self.right[2]: self.location_of_constraint+=right_mask*[0.,0.,1.]                  if self.left[2]: self._location_of_constraint+=left_mask*[0.,0.,1.]
233               front_mask=(x[1]-inf(x[1])).whereZero()                  right_mask=whereZero(x[0]-sup(x[0]))
234               if self.front[0]: self.location_of_constraint+=front_mask*[1.,0.,0.]                  if self.right[0]: self._location_of_constraint+=right_mask*[1.,0.,0.]
235               if self.front[1]: self.location_of_constraint+=front_mask*[0.,1.,0.]                  if self.right[1]: self._location_of_constraint+=right_mask*[0.,1.,0.]
236               if self.front[2]: self.location_of_constraint+=front_mask*[0.,0.,1.]                  if self.right[2]: self._location_of_constraint+=right_mask*[0.,0.,1.]
237               back_mask=(x[1]-sup(x[1])).whereZero()                  front_mask=whereZero(x[1]-inf(x[1]))
238               if self.back[0]: self.location_of_constraint+=back_mask*[1.,0.,0.]                  if self.front[0]: self._location_of_constraint+=front_mask*[1.,0.,0.]
239               if self.back[1]: self.location_of_constraint+=back_mask*[0.,1.,0.]                  if self.front[1]: self._location_of_constraint+=front_mask*[0.,1.,0.]
240               if self.back[2]: self.location_of_constraint+=back_mask*[0.,0.,1.]                  if self.front[2]: self._location_of_constraint+=front_mask*[0.,0.,1.]
241               bottom_mask=(x[2]-inf(x[2])).whereZero()                  back_mask=whereZero(x[1]-sup(x[1]))
242               if self.bottom[0]: self.location_of_constraint+=bottom_mask*[1.,0.,0.]                  if self.back[0]: self._location_of_constraint+=back_mask*[1.,0.,0.]
243               if self.bottom[1]: self.location_of_constraint+=bottom_mask*[0.,1.,0.]                  if self.back[1]: self._location_of_constraint+=back_mask*[0.,1.,0.]
244               if self.bottom[2]: self.location_of_constraint+=bottom_mask*[0.,0.,1.]                  if self.back[2]: self._location_of_constraint+=back_mask*[0.,0.,1.]
245               top_mask=(x[2]-sup(x[2])).whereZero()                  bottom_mask=whereZero(x[2]-inf(x[2]))
246               if self.top[0]: self.location_of_constraint+=top_mask*[1.,0.,0.]                  if self.bottom[0]: self._location_of_constraint+=bottom_mask*[1.,0.,0.]
247               if self.top[1]: self.location_of_constraint+=top_mask*[0.,1.,0.]                  if self.bottom[1]: self._location_of_constraint+=bottom_mask*[0.,1.,0.]
248               if self.top[2]: self.location_of_constraint+=top_mask*[0.,0.,1.]                  if self.bottom[2]: self._location_of_constraint+=bottom_mask*[0.,0.,1.]
249            else:                  top_mask=whereZero(x[2]-sup(x[2]))
250               left_mask=(x[0]-inf(x[0])).whereZero()                  if self.top[0]: self._location_of_constraint+=top_mask*[1.,0.,0.]
251               if self.left[0]: self.location_of_constraint+=left_mask*[1.,0.]                  if self.top[1]: self._location_of_constraint+=top_mask*[0.,1.,0.]
252               if self.left[1]: self.location_of_constraint+=left_mask*[0.,1.]                  if self.top[2]: self._location_of_constraint+=top_mask*[0.,0.,1.]
253               right_mask=(x[0]-inf(x[0])).whereZero()               else:
254               if self.right[0]: self.location_of_constraint+=right_mask*[1.,0.]                  left_mask=whereZero(x[0]-inf(x[0]))
255               if self.right[1]: self.location_of_constraint+=right_mask*[0.,1.]                  if self.left[0]: self._location_of_constraint+=left_mask*[1.,0.]
256               bottom_mask=(x[1]-inf(x[1])).whereZero()                  if self.left[1]: self._location_of_constraint+=left_mask*[0.,1.]
257               if self.bottom[0]: self.location_of_constraint+=bottom_mask*[1.,0.]                  right_mask=whereZero(x[0]-sup(x[0]))
258               if self.bottom[1]: self.location_of_constraint+=bottom_mask*[0.,1.]                  if self.right[0]: self._location_of_constraint+=right_mask*[1.,0.]
259               top_mask=(x[1]-sup(x[1])).whereZero()                  if self.right[1]: self._location_of_constraint+=right_mask*[0.,1.]
260               if self.top[0]: self.location_of_constraint+=top_mask*[1.,0.]                  bottom_mask=whereZero(x[1]-inf(x[1]))
261               if self.top[1]: self.location_of_constraint+=top_mask*[0.,1.]                  if self.bottom[0]: self._location_of_constraint+=bottom_mask*[1.,0.]
262                    if self.bottom[1]: self._location_of_constraint+=bottom_mask*[0.,1.]
263                    top_mask=whereZero(x[1]-sup(x[1]))
264                    if self.top[0]: self._location_of_constraint+=top_mask*[1.,0.]
265                    if self.top[1]: self._location_of_constraint+=top_mask*[0.,1.]
266              return self._location_of_constraint
267    
268    # vim: expandtab shiftwidth=4:

Legend:
Removed from v.127  
changed lines
  Added in v.406

  ViewVC Help
Powered by ViewVC 1.1.26