/[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 490 by gross, Thu Feb 2 07:07:21 2006 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               tol=1.e-8
100               x=self.domain.getX()
101               d=self.domain.getDim()
102               self.location_constrained_value=0
103               x0=x[0]
104               mx=sup(x0)
105               mn=inf(x0)
106               if self.left:
107                   self.location_constrained_value=self.location_constrained_value+whereZero(x0-mn,tol*(mx-mn))
108               if self.right:
109                   self.location_constrained_value=self.location_constrained_value+whereZero(x0-mx,tol*(mx-mn))
110               x0=x[d-1]
111               mx=sup(x0)
112               mn=inf(x0)
113               if self.bottom:
114                   self.location_constrained_value=self.location_constrained_value+whereZero(x0-mn,tol*(mx-mn))
115               if self.top:
116                   self.location_constrained_value=self.location_constrained_value+whereZero(x0-mx,tol*(mx-mn))
117               if d>2:
118                  x0=x[1]
119                  mx=sup(x0)
120                  mn=inf(x0)
121                  if self.front:
122                     self.location_constrained_value=self.location_constrained_value+whereZero(x0-mn,tol*(mx-mn))
123                  if self.back:
124                     self.location_constrained_value=self.location_constrained_value+whereZero(x0-mx,tol*(mx-mn))          
125               self.constrain_value=self.value*self.location_constrained_value
126              
127    class ScalarConstrainer(ParameterSet):
128         """
129         Creates a characteristic function for the location of constraints
130         for a scalar value.
131    
132         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
133         and back are ignored.
134    
135         @ivar domain (in): rectangular domain
136         @ivar left (in): True to set a constraint at the left face of the
137                   domain (x[0]=min x[0]), default is False
138         @ivar right (in): True to set a constraint at the left face of the
139                   domain (x[0]=max x[0]), default is False
140         @ivar top (in): True to set a constraint at the left face of the
141                   domain (x[1]=min x[1]), default is False
142         @ivar bottom (in): True to set a constraint at the left face of the
143                   domain (x[1]=max x[1]), default is False
144         @ivar front (in): True to set a constraint at the left face of the
145                   domain (x[2]=min x[2]), default is False
146         @ivar back (in): True to set a constraint at the left face of the
147                   domain (x[2]=max x[2]), default is False
148         @ivar location_of_constraint (out): object that defines the location
149                   of the constraints.
150       """       """
151       def __init__(self,debug=False):       def __init__(self,debug=False):
152             Model.__init__(self,debug=debug)             ParameterSet.__init__(self,debug=debug)
153             self.declareParameter(domain=None, \             self.declareParameter(domain=None, \
154                                   left=False,                                   left=False, \
155                                   right=False,                                   right=False, \
156                                   top=False,                                   top=False, \
157                                   bottom=False,                                   bottom=False, \
158                                   front=False,                                   front=False, \
159                                   back=False,                                   back=False)
160                                   location_of_constraint=Data())             self._location_of_constraint=None
161       def doInitialization(self,t):  
162            x=self.domain.getX()       def location_of_constraint(self):
163            self.location_of_constraint=Scalar(0,x.getFunctionSpace())            """
164            if self.domain.getDim()==3:            Returns the mask of the location of constraint.
165               if self.left: self.location_of_constraint+=(x[0]-inf(x[0])).whereZero()            """
166               if self.right: self.location_of_constraint+=(x[0]-sup(x[0])).whereZero()            if self._location_of_constraint==None:
167               if self.front: self.location_of_constraint+=(x[1]-inf(x[1])).whereZero()               x=self.domain.getX()
168               if self.back: self.location_of_constraint+=(x[1]-sup(x[1])).whereZero()               self._location_of_constraint=Scalar(0,x.getFunctionSpace())
169               if self.bottom: self.location_of_constraint+=(x[2]-inf(x[2])).whereZero()               if self.domain.getDim()==3:
170               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]))
171            else:                  if self.right: self._location_of_constraint+=whereZero(x[0]-sup(x[0]))
172               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]))
173               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]))
174               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]))
175               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]))
176                 else:
177  class VectorConstrainer(Model):                  if self.left: self._location_of_constraint+=whereZero(x[0]-inf(x[0]))
178        """@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]))
179                    if self.bottom: self._location_of_constraint+=whereZero(x[1]-inf(x[1]))
180                @param domain (in) - rectangular domain                  if self.top: self._location_of_constraint+=whereZero(x[1]-sup(x[1]))
181                @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.  
182    
183         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):
184          """
185          Creates a characteristic function for the location of constraints
186          for a scalar value.
187    
188          @ivar domain (in): rectangular domain
189          @ivar left (in): list of three boolean. left[i]==True sets a
190                    constraint for the i-th component at the left
191                    face of the domain (x[0]=min x[0]),
192                    default is [False,False,False]
193          @ivar right (in): list of three boolean. left[i]==True sets a
194                    constraint for the i-th component at the right
195                    face of the domain (x[0]=max x[0]),
196                    default is [False,False,False]
197          @ivar top (in): list of three boolean. left[i]==True sets a
198                    constraint for the i-th component at the top
199                    face of the domain (x[1]=min x[1]),
200                    default is [False,False,False]
201          @ivar bottom (in): list of three boolean. left[i]==True sets a
202                    constraint for the i-th component at the bottom
203                    face of the domain (x[1]=min x[1]),
204                    default is [False,False,False]
205          @ivar front (in): list of three boolean. left[i]==True sets a
206                    constraint for the i-th component at the front
207                    face of the domain (x[2]=min x[2]),
208                    default is [False,False,False]
209          @ivar back (in): list of three boolean. left[i]==True sets a
210                    constraint for the i-th component at the back
211                    face of the domain (x[2]=max x[2]),
212                    default is [False,False,False]
213          @ivar location_of_constraint (callable): object that defines the location of the constraints for each vector component.
214    
215          In the case that the spatial dimension is two, thh arguments front and
216          back as well as the third component of each argument is ignored.
217        """        """
218        def __init__(self,debug=False):        def __init__(self,debug=False):
219             Model.__init__(self,debug=debug)             ParameterSet.__init__(self,debug=debug)
220             self.declareParameter(domain=None, \             self.declareParameter(domain=None, \
221                                   left=[0,0,0],                                   left=[0,0,0],  \
222                                   right=[0,0,0],                                   right=[0,0,0],  \
223                                   top=[0,0,0],                                   top=[0,0,0],  \
224                                   bottom=[0,0,0],                                   bottom=[0,0,0],  \
225                                   front=[0,0,0],                                   front=[0,0,0],
226                                   back=[0,0,0],                                   back=[0,0,0])
227                                   location_of_constraint=Data())             self._location_of_constraint=None
228        def doInitialization(self,t):        def location_of_constraint(self):
229            x=self.domain.getX()            """
230            self.location_of_constraint=Vector(0,x.getFunctionSpace())            Returns the mask of the location of constraint.
231            if self.domain.getDim()==3:            """
232               left_mask=(x[0]-inf(x[0])).whereZero()            if self._location_of_constraint==None:
233               if self.left[0]: self.location_of_constraint+=left_mask*[1.,0.,0.]               x=self.domain.getX()
234               if self.left[1]: self.location_of_constraint+=left_mask*[0.,1.,0.]               self._location_of_constraint=Vector(0,x.getFunctionSpace())
235               if self.left[2]: self.location_of_constraint+=left_mask*[0.,0.,1.]               if self.domain.getDim()==3:
236               right_mask=(x[0]-inf(x[0])).whereZero()                  left_mask=whereZero(x[0]-inf(x[0]))
237               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.]
238               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.]
239               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.]
240               front_mask=(x[1]-inf(x[1])).whereZero()                  right_mask=whereZero(x[0]-sup(x[0]))
241               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.]
242               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.]
243               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.]
244               back_mask=(x[1]-sup(x[1])).whereZero()                  front_mask=whereZero(x[1]-inf(x[1]))
245               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.]
246               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.]
247               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.]
248               bottom_mask=(x[2]-inf(x[2])).whereZero()                  back_mask=whereZero(x[1]-sup(x[1]))
249               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.]
250               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.]
251               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.]
252               top_mask=(x[2]-sup(x[2])).whereZero()                  bottom_mask=whereZero(x[2]-inf(x[2]))
253               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.]
254               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.]
255               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.]
256            else:                  top_mask=whereZero(x[2]-sup(x[2]))
257               left_mask=(x[0]-inf(x[0])).whereZero()                  if self.top[0]: self._location_of_constraint+=top_mask*[1.,0.,0.]
258               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.]
259               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.]
260               right_mask=(x[0]-inf(x[0])).whereZero()               else:
261               if self.right[0]: self.location_of_constraint+=right_mask*[1.,0.]                  left_mask=whereZero(x[0]-inf(x[0]))
262               if self.right[1]: self.location_of_constraint+=right_mask*[0.,1.]                  if self.left[0]: self._location_of_constraint+=left_mask*[1.,0.]
263               bottom_mask=(x[1]-inf(x[1])).whereZero()                  if self.left[1]: self._location_of_constraint+=left_mask*[0.,1.]
264               if self.bottom[0]: self.location_of_constraint+=bottom_mask*[1.,0.]                  right_mask=whereZero(x[0]-sup(x[0]))
265               if self.bottom[1]: self.location_of_constraint+=bottom_mask*[0.,1.]                  if self.right[0]: self._location_of_constraint+=right_mask*[1.,0.]
266               top_mask=(x[1]-sup(x[1])).whereZero()                  if self.right[1]: self._location_of_constraint+=right_mask*[0.,1.]
267               if self.top[0]: self.location_of_constraint+=top_mask*[1.,0.]                  bottom_mask=whereZero(x[1]-inf(x[1]))
268               if self.top[1]: self.location_of_constraint+=top_mask*[0.,1.]                  if self.bottom[0]: self._location_of_constraint+=bottom_mask*[1.,0.]
269                    if self.bottom[1]: self._location_of_constraint+=bottom_mask*[0.,1.]
270                    top_mask=whereZero(x[1]-sup(x[1]))
271                    if self.top[0]: self._location_of_constraint+=top_mask*[1.,0.]
272                    if self.top[1]: self._location_of_constraint+=top_mask*[0.,1.]
273              return self._location_of_constraint
274    
275    # vim: expandtab shiftwidth=4:

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

  ViewVC Help
Powered by ViewVC 1.1.26