/[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

revision 490 by gross, Thu Feb 2 07:07:21 2006 UTC revision 953 by gross, Fri Feb 9 08:55:28 2007 UTC
# Line 1  Line 1 
1  # $Id$  # $Id$
2    
3    __copyright__="""  Copyright (c) 2006 by ACcESS MNRF
4                        http://www.access.edu.au
5                    Primary Business: Queensland, Australia"""
6    __license__="""Licensed under the Open Software License version 3.0
7                 http://www.opensource.org/licenses/osl-3.0.php"""
8    
9    
10  from esys.escript import *  from esys.escript import *
11  from esys.escript.modelframe import Model,ParameterSet  from esys.escript.modelframe import Model,ParameterSet
12    from esys.pycad import TagMap
13  from esys import finley  from esys import finley
14    
15  class FinleyReader(ParameterSet):  class FinleyReader(ParameterSet):
16         """         """
17         Generates a mesh over a rectangular domain finley.         reads finley mesh file.
18    
19         @ivar filename:         @ivar source: mesh file in finley or gmsh format
20         @ivar intergrationOrder         @type source: C{DataSource}
21         @ivar domain:         @ivar intergrationOrder: integration order, default -1 (in).
22           @type intergrationOrder: C{int}
23           @ivar reducedIntegrationOrder: reduced integration order, default -1 (in).
24           @type reducedIntegrationOrder: C{int}
25           @ivar optimizeLabeling: switches on optimization of the labeling of the nodes
26           @type optimizeLabeling: C{bool}
27         """         """
28         def __init__(self,debug=False):         def __init__(self,**kwargs):
29             super(FinleyReader,self).__init__(debug=debug)            """
30             ParameterSet.__init__(self,debug=debug)            initializes the object
31             self.declareParameter(source="none",\            """
32                                   integrationOrder=-1)            super(FinleyReader,self).__init__(**kwargs)
33             self._domain=None            self.declareParameter(source="none",
34                                    region_tag_map_source=None,
35                                    surface_tag_map_source=None,
36                                    optimizeLabeling=True,
37                                    reducedIntegrationOrder=-1,
38                                    integrationOrder=-1)
39              self.__domain=None
40              self.__region_tag_map=None
41              self.__surface_tag_map=None
42    
43    
44         def domain(self):         def domain(self):
45            if self._domain==None:            """
46                self._domain=finley.ReadMesh(self.source,self.integrationOrder)            returns the domain
47                self.trace("mesh read from %s"%self.source)            
48            return self._domain            @return: the domain
49              @rtype: L{Domain}
50              """
51              if self.__domain == None:
52                 if  self.source.fileformat == "fly":
53                    self.__domain=finley.ReadMesh(self.source.getLocalFileName(),self.integrationOrder)
54                 elif self.source.fileformat == "gmsh":
55                    self.__domain=finley.ReadGmsh(self.source.getLocalFileName(),self.integrationOrder,self.reducedIntegrationOrder, self.optimizeLabeling)
56                 else:
57                    raise TypeError("unknown mesh file format %s."%self.source.fileformat)
58                 self.trace("mesh read from %s in %s format."%(self.source.getLocalFileName(), self.source.fileformat))          
59              return self.__domain
60    
61           def region_tag_map(self):
62              """
63              returns the map from regional tag names to tag integers used in the mesh
64    
65              @return: the tag map
66              @rtype: L{TagMap}
67              """
68              if self.__region_tag_map == None:
69                   self.__region_tag_map = TagMap()
70                   if  self.region_tag_map_source != None:
71                       self.__region_tag_map.fillFromXML(open(self.region_tag_map_source.getLocalFileName()))
72                   self.trace("region tag map read from %s in %s format."%(self.region_tag_map_source.getLocalFileName(), self.region_tag_map_source.fileformat))          
73              return self.__region_tag_map
74    
75           def surface_tag_map(self):
76              """
77              returns the map from surface tag names to tag integers used in the mesh
78    
79              @return: the tag map
80              @rtype: L{TagMap}
81              """
82              if self.__surface_tag_map == None:
83                   self.__surface_tag_map = TagMap()
84                   if  self.surface_tag_map_source != None:
85                       self.__surface_tag_map.fillFromXML(open(self.surface_tag_map_source.getLocalFileName()))
86                   self.trace("surface tag map read from %s in %s format."%(self.surface_tag_map_source.getLocalFileName(), self.surface_tag_map_source.fileformat))          
87              return self.__surface_tag_map
88              
89                                                
90  class RectangularDomain(ParameterSet):  class RectangularDomain(ParameterSet):
91         """         """
92         Generates a mesh over a rectangular domain finley.         Generates a mesh over a rectangular domain finley.
93    
94         @ivar dim:         @ivar dim: spatial dimension, default =2 (in).
95         @ivar l:         @type dim: spatial dimension
96         @ivar n:         @ivar l: spatial lengths, default [1.,1.,1.] (in).
97         @ivar order:         @type l: C{list} of C{floats}s
98         @ivar periodic:         @ivar n: number of elements, default [10,10,10] (in).
99         @ivar intergration order:         @type n: C{list} of C{int}s
100         @ivar domain:         @ivar order: element order, default 1 (in).
101           @type order: C{int}
102           @ivar periodic: flags for periodicity, default [False,False,False] (in).
103           @type periodic: C{list} of C{bool}s
104           @ivar intergrationOrder: integration order, default -1 (in).
105           @type intergrationOrder: C{int}
106         """         """
107         def __init__(self,debug=False):         def __init__(self,**kwargs):
108             super(RectangularDomain,self).__init__(debug=debug)             """
109               initializes the object
110               """
111               super(RectangularDomain,self).__init__(**kwargs)
112             self.declareParameter(dim=2,\             self.declareParameter(dim=2,\
113                                   l=[1.,1.,1.],\                                   l=[1.,1.,1.],\
114                                   n=[10,10,10], \                                   n=[10,10,10], \
115                   order=1,\                   order=1,\
116                                   periodic=[False,False,False],\                                   periodic=[False,False,False],
117                                   integrationOrder=-1)                                   integrationOrder=-1)
118             self._domain=None             self.__domain=None
119    
120         def domain(self):         def domain(self):
121            if self._domain==None:             """
122               if self.dim==2:             returns the domain
                 self._domain=finley.Rectangle(n0=self.n[0],\  
                                              n1=self.n[1],\  
                                              l0=self.l[0],\  
                                              l1=self.l[1],\  
                                              order=self.order, \  
                                              periodic0=self.periodic[0], \  
                                              periodic1=self.periodic[1], \  
                                              integrationOrder=self.integrationOrder)  
              else:  
                 self._domain=finley.Brick(n0=self.n[0],\  
                                          n1=self.n[1],\  
                                          n2=self.n[2],\  
                                          l0=self.l[0],\  
                                          l1=self.l[1],\  
                                          l2=self.l[2],\  
                                          order=self.order, \  
                                          periodic0=self.periodic[0], \  
                                          periodic1=self.periodic[1], \  
                                          periodic2=self.periodic[2], \  
                                          integrationOrder=self.integrationOrder)  
123    
124            return self._domain             @return: the domain
125               @rtype: L{Domain}
126               """
127               if self.__domain==None:
128                  if self.dim==2:
129                       self.__domain=finley.Rectangle(n0=self.n[0],\
130                                                    n1=self.n[1],\
131                                                    l0=self.l[0],\
132                                                    l1=self.l[1],\
133                                                    order=self.order, \
134                                                    periodic0=self.periodic[0], \
135                                                    periodic1=self.periodic[1], \
136                                                    integrationOrder=self.integrationOrder)
137                  else:
138                       self.__domain=finley.Brick(n0=self.n[0],\
139                                                n1=self.n[1],\
140                                                n2=self.n[2],\
141                                                l0=self.l[0],\
142                                                l1=self.l[1],\
143                                                l2=self.l[2],\
144                                                order=self.order, \
145                                                periodic0=self.periodic[0], \
146                                                periodic1=self.periodic[1], \
147                                                periodic2=self.periodic[2], \
148                                                integrationOrder=self.integrationOrder)
149               return self.__domain
150    
151  class ConstrainValue(Model):  class UpdateGeometry(Model):
152         """        """
153         selects values for a given distribution to be used as a constrain. the location of the        applies a displacement field to a domain
154         constrain are he faces of a rectangular domain. This Model is typically used in        
155         time dependend problems to fix the values in a given initial condition.        @ivar displacement: displacements applied to the original mesh coordinates (in).
156         """        @type displacement: L{escript.Vector}
157         def __init__(self,debug=False):        @ivar domain: domain
158             Model.__init__(self,debug=debug)        @type domain: L{escript.Domain}
159             self.declareParameter(domain=None, \        """
160                                   value=0,  \        def __init__(self,**kwargs):
                                  top=True,  \  
                                  bottom=True,\  
                                  front=False, \  
                                  back=False,\  
                                  left=False,\  
                                  right=False,\  
                                  constrain_value = None,  \  
                                  location_constrained_value=None)  
        def doInitialization(self):  
161             """             """
162             initialize time stepping             set-up the object
163             """             """
164             tol=1.e-8             super(UpdateGeometry, self).__init__(**kwargs)
165             x=self.domain.getX()             self.declareParameter(domain=None,\
166             d=self.domain.getDim()                                   displacement=None)
167             self.location_constrained_value=0  
168             x0=x[0]  
169             mx=sup(x0)        def doInitialization(self):
170             mn=inf(x0)           """
171             if self.left:           initialize model
172                 self.location_constrained_value=self.location_constrained_value+whereZero(x0-mn,tol*(mx-mn))           """
173             if self.right:           self.__x=self.domain.getX()
174                 self.location_constrained_value=self.location_constrained_value+whereZero(x0-mx,tol*(mx-mn))           self.__reset=True
175             x0=x[d-1]          
176             mx=sup(x0)        def doStepPreprocessing(self,dt):
177             mn=inf(x0)           """
178             if self.bottom:           applies the current L{displacement} to mesh nodes if required.
179                 self.location_constrained_value=self.location_constrained_value+whereZero(x0-mn,tol*(mx-mn))           """
180             if self.top:           if self.__reset:
181                 self.location_constrained_value=self.location_constrained_value+whereZero(x0-mx,tol*(mx-mn))              self.trace("mesh nodes updated.")
182             if d>2:              self.domain.setX(self.__x+self.displacement)
183                x0=x[1]           self.__reset=False
184                mx=sup(x0)  
185                mn=inf(x0)        def doStep(self,dt):
186                if self.front:           """
187                   self.location_constrained_value=self.location_constrained_value+whereZero(x0-mn,tol*(mx-mn))           applies the current L{displacement} to mesh nodes.
188                if self.back:           """
189                   self.location_constrained_value=self.location_constrained_value+whereZero(x0-mx,tol*(mx-mn))                     self.trace("mesh nodes updated.")
190             self.constrain_value=self.value*self.location_constrained_value           self.domain.setX(self.__x+self.displacement)
191                       self.__reset=True
192  class ScalarConstrainer(ParameterSet):  
193       """        def doStepPostprocessing(self,dt):
194       Creates a characteristic function for the location of constraints           """
195       for a scalar value.           marks nodes as beeing updated.
196             """
197       In the case that the spatial dimension is two, the arguments front           self.__reset=False
198       and back are ignored.  
199    class ConstrainerOverBox(Model):
200       @ivar domain (in): rectangular domain        """
201       @ivar left (in): True to set a constraint at the left face of the        Creates a characteristic function for the location of constraints
202                 domain (x[0]=min x[0]), default is False        for all components of a value and selects the value from an initial value
203       @ivar right (in): True to set a constraint at the left face of the        ate these locations.
204                 domain (x[0]=max x[0]), default is False  
205       @ivar top (in): True to set a constraint at the left face of the        In the case that the spatial dimension is two, the arguments front and back are ignored.
206                 domain (x[1]=min x[1]), default is False  
207       @ivar bottom (in): True to set a constraint at the left face of the        @ivar domain: domain (in).
208                 domain (x[1]=max x[1]), default is False        @ivar left:  True to set a constraint at the left face of the domain (x[0]=min x[0]), default False (in).
209       @ivar front (in): True to set a constraint at the left face of the        @ivar right: True to set a constraint at the left face of the domain (x[0]=max x[0]), default False (in).
210                 domain (x[2]=min x[2]), default is False        @ivar top: True to set a constraint at the left face of the domain (x[1]=min x[1]), default False (in).
211       @ivar back (in): True to set a constraint at the left face of the        @ivar bottom: True to set a constraint at the left face of the domain (x[1]=max x[1]), default False (in).
212                 domain (x[2]=max x[2]), default is False        @ivar front: True to set a constraint at the left face of the domain (x[2]=min x[2]), default False (in).
213       @ivar location_of_constraint (out): object that defines the location        @ivar back: True to set a constraint at the left face of the domain (x[2]=max x[2]), default False (in).
214                 of the constraints.        @ivar tol: absolute tolerance for "x=max x" condition, default 1.e-8 (in).
215       """        """
216       def __init__(self,debug=False):        def __init__(self,**kwargs):
217             ParameterSet.__init__(self,debug=debug)             super(ConstrainerOverBox, self).__init__(**kwargs)
218             self.declareParameter(domain=None, \             self.declareParameter(domain=None, \
219                                     value=None,  \
220                                   left=False, \                                   left=False, \
221                                   right=False, \                                   right=False, \
222                                   top=False, \                                   top=False, \
223                                   bottom=False, \                                   bottom=False, \
224                                   front=False, \                                   front=False, \
225                                   back=False)                                   back=False, \
226             self._location_of_constraint=None                                   tol=1.e-8)
227               self.__value_of_constraint = None
228               self.__location_of_constraint=None
229          def location_of_constraint(self):
230              """
231              return the values used to constrain a solution
232    
233       def location_of_constraint(self):            @return: the mask marking the locations of the constraints
234              @rtype: L{escript.Scalar}
235            """            """
236            Returns the mask of the location of constraint.            if self.__location_of_constraint == None: self.__setOutput()
237              return self.__location_of_constraint
238            
239          def value_of_constraint(self):
240            """            """
241            if self._location_of_constraint==None:            return the values used to constrain a solution
              x=self.domain.getX()  
              self._location_of_constraint=Scalar(0,x.getFunctionSpace())  
              if self.domain.getDim()==3:  
                 if self.left: self._location_of_constraint+=whereZero(x[0]-inf(x[0]))  
                 if self.right: self._location_of_constraint+=whereZero(x[0]-sup(x[0]))  
                 if self.front: self._location_of_constraint+=whereZero(x[1]-inf(x[1]))  
                 if self.back: self._location_of_constraint+=whereZero(x[1]-sup(x[1]))  
                 if self.bottom: self._location_of_constraint+=whereZero(x[2]-inf(x[2]))  
                 if self.top: self._location_of_constraint+=whereZero(x[2]-sup(x[2]))  
              else:  
                 if self.left: self._location_of_constraint+=whereZero(x[0]-inf(x[0]))  
                 if self.right: self._location_of_constraint+=whereZero(x[0]-sup(x[0]))  
                 if self.bottom: self._location_of_constraint+=whereZero(x[1]-inf(x[1]))  
                 if self.top: self._location_of_constraint+=whereZero(x[1]-sup(x[1]))  
           return self._location_of_constraint  
242    
243  class VectorConstrainer(ParameterSet):            @return: values to be used at the locations of the constraints. If
244                      L{value} is not given C{None} is rerturned.
245              @rtype: L{escript.Scalar}
246              """
247              if self.__location_of_constraint == None: self.__setOutput()
248              return self.__value_of_constraint
249            
250          def __setOutput(self):
251              x=self.domain.getX()
252              val=self.value
253              if isinstance(val, int) or isinstance(val, float):
254                 shape=()
255              elif isinstance(val, list) or isinstance(val, tuple) :
256                 shape=(len(val),)
257              elif isinstance(val, numarray.NumArray):
258                  shape=val.shape
259              else:
260                  shape=val.getShape()
261              self.__location_of_constraint=Data(0,shape,x.getFunctionSpace())
262              if self.domain.getDim()==3:
263                    x0,x1,x2=x[0],x[1],x[2]
264                    if self.left: self.__location_of_constraint+=whereZero(x0-inf(x0),self.tol)
265                    if self.right: self.__location_of_constraint+=whereZero(x0-sup(x0),self.tol)
266                    if self.front: self.__location_of_constraint+=whereZero(x1-inf(x1),self.tol)
267                    if self.back: self.__location_of_constraint+=whereZero(x1-sup(x1),self.tol)
268                    if self.bottom: self.__location_of_constraint+=whereZero(x2-inf(x2),self.tol)
269                    if self.top: self.__location_of_constraint+=whereZero(x2-sup(x2),self.tol)
270              else:
271                    x0,x1=x[0],x[1]
272                    if self.left: self.__location_of_constraint+=whereZero(x0-inf(x0),self.tol)
273                    if self.right: self.__location_of_constraint+=whereZero(x0-sup(x0),self.tol)
274                    if self.bottom: self.__location_of_constraint+=whereZero(x1-inf(x1),self.tol)
275                    if self.top: self.__location_of_constraint+=whereZero(x1-sup(x1),self.tol)
276              self.__value_of_constraint=self.__location_of_constraint*self.value
277    class ScalarConstrainerOverBox(Model):
278        """        """
279        Creates a characteristic function for the location of constraints        Creates a characteristic function for the location of constraints
280        for a scalar value.        for a scalar value and selects the value from an initial value
281          ate these locations.
282    
283        @ivar domain (in): rectangular domain        In the case that the spatial dimension is two, the arguments front and back are ignored.
       @ivar left (in): list of three boolean. left[i]==True sets a  
                 constraint for the i-th component at the left  
                 face of the domain (x[0]=min x[0]),  
                 default is [False,False,False]  
       @ivar 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]  
       @ivar 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]  
       @ivar 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]  
       @ivar 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]  
       @ivar 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]  
       @ivar location_of_constraint (callable): object that defines the location of the constraints for each vector component.  
284    
285        In the case that the spatial dimension is two, thh arguments front and        @ivar domain: domain (in).
286          @ivar left:  True to set a constraint at the left face of the domain (x[0]=min x[0]), default False (in).
287          @ivar right: True to set a constraint at the left face of the domain (x[0]=max x[0]), default False (in).
288          @ivar top: True to set a constraint at the left face of the domain (x[1]=min x[1]), default False (in).
289          @ivar bottom: True to set a constraint at the left face of the domain (x[1]=max x[1]), default False (in).
290          @ivar front: True to set a constraint at the left face of the domain (x[2]=min x[2]), default False (in).
291          @ivar back: True to set a constraint at the left face of the domain (x[2]=max x[2]), default False (in).
292          @ivar tol: absolute tolerance for "x=max x" condition, default 1.e-8 (in).
293          """
294          def __init__(self,**kwargs):
295               super(ScalarConstrainerOverBox, self).__init__(**kwargs)
296               self.declareParameter(domain=None, \
297                                     value=None,  \
298                                     left=False, \
299                                     right=False, \
300                                     top=False, \
301                                     bottom=False, \
302                                     front=False, \
303                                     back=False, \
304                                     tol=1.e-8)
305               self.__value_of_constraint = None
306               self.__location_of_constraint=None
307          def location_of_constraint(self):
308              """
309              return the values used to constrain a solution
310    
311              @return: the mask marking the locations of the constraints
312              @rtype: L{escript.Scalar}
313              """
314              if self.__location_of_constraint == None: self.__setOutput()
315              return self.__location_of_constraint
316            
317          def value_of_constraint(self):
318              """
319              return the values used to constrain a solution
320    
321              @return: values to be used at the locations of the constraints. If
322                      L{value} is not given C{None} is rerturned.
323              @rtype: L{escript.Scalar}
324              """
325              if self.__location_of_constraint == None: self.__setOutput()
326              return self.__value_of_constraint
327            
328          def __setOutput(self):
329              x=self.domain.getX()
330              self.__location_of_constraint=Scalar(0,x.getFunctionSpace())
331              if self.domain.getDim()==3:
332                    x0,x1,x2=x[0],x[1],x[2]
333                    if self.left: self.__location_of_constraint+=whereZero(x0-inf(x0),self.tol)
334                    if self.right: self.__location_of_constraint+=whereZero(x0-sup(x0),self.tol)
335                    if self.front: self.__location_of_constraint+=whereZero(x1-inf(x1),self.tol)
336                    if self.back: self.__location_of_constraint+=whereZero(x1-sup(x1),self.tol)
337                    if self.bottom: self.__location_of_constraint+=whereZero(x2-inf(x2),self.tol)
338                    if self.top: self.__location_of_constraint+=whereZero(x2-sup(x2),self.tol)
339              else:
340                    x0,x1=x[0],x[1]
341                    if self.left: self.__location_of_constraint+=whereZero(x0-inf(x0),self.tol)
342                    if self.right: self.__location_of_constraint+=whereZero(x0-sup(x0),self.tol)
343                    if self.bottom: self.__location_of_constraint+=whereZero(x1-inf(x1),self.tol)
344                    if self.top: self.__location_of_constraint+=whereZero(x1-sup(x1),self.tol)
345              if self.value:
346                  self.__value_of_constraint=self.__location_of_constraint*self.value
347    
348    class VectorConstrainerOverBox(Model):
349          """
350          Creates a characteristic function for the location of constraints vector value.
351          In the case that the spatial dimension is two, the arguments front and
352        back as well as the third component of each argument is ignored.        back as well as the third component of each argument is ignored.
353    
354          @ivar domain: domain
355          @ivar left: list of three boolean. left[i]==True sets a constraint for the i-th component at the left face of the domain (x[0]=min x[0]),
356                           default [False,False,False] (in).
357          @ivar right: 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]),
358                    default [False,False,False] (in).
359          @ivar top: 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]),
360                    default [False,False,False] (in).
361          @ivar bottom: 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]),
362                    default [False,False,False] (in).
363          @ivar front: 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]),
364                    default [False,False,False] (in).
365          @ivar back: 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]),
366                    default [False,False,False] (in).
367          @ivar tol: absolute tolerance for "x=max x" condition, default 1.e-8 (in).
368        """        """
369        def __init__(self,debug=False):        def __init__(self, **kwargs):
370             ParameterSet.__init__(self,debug=debug)             super(VectorConstrainerOverBox, self).__init__(**kwargs)
371             self.declareParameter(domain=None, \             self.declareParameter(domain=None, \
372                                     value=None,  \
373                                   left=[0,0,0],  \                                   left=[0,0,0],  \
374                                   right=[0,0,0],  \                                   right=[0,0,0],  \
375                                   top=[0,0,0],  \                                   top=[0,0,0],  \
376                                   bottom=[0,0,0],  \                                   bottom=[0,0,0],  \
377                                   front=[0,0,0],                                   front=[0,0,0], \
378                                   back=[0,0,0])                                   back=[0,0,0], \
379             self._location_of_constraint=None                                   tol=1.e-8)
380               self.__value_of_constraint = None
381               self.__location_of_constraint=None
382    
383        def location_of_constraint(self):        def location_of_constraint(self):
384            """            """
385            Returns the mask of the location of constraint.            return the values used to constrain a solution
386    
387              @return: the mask marking the locations of the constraints
388              @rtype: L{escript.Vector}
389            """            """
390            if self._location_of_constraint==None:            if self.__location_of_constraint == None: self.__setOutput()
391               x=self.domain.getX()            return self.__location_of_constraint
392               self._location_of_constraint=Vector(0,x.getFunctionSpace())          
393               if self.domain.getDim()==3:        def value_of_constraint(self):
394                  left_mask=whereZero(x[0]-inf(x[0]))            """
395                  if self.left[0]: self._location_of_constraint+=left_mask*[1.,0.,0.]            return the values used to constrain a solution
396                  if self.left[1]: self._location_of_constraint+=left_mask*[0.,1.,0.]  
397                  if self.left[2]: self._location_of_constraint+=left_mask*[0.,0.,1.]            @return: values to be used at the locations of the constraints. If
398                  right_mask=whereZero(x[0]-sup(x[0]))                    L{value} is not given C{None} is rerturned.
399                  if self.right[0]: self._location_of_constraint+=right_mask*[1.,0.,0.]            @rtype: L{escript.Vector}
400                  if self.right[1]: self._location_of_constraint+=right_mask*[0.,1.,0.]            """
401                  if self.right[2]: self._location_of_constraint+=right_mask*[0.,0.,1.]            if self.__location_of_constraint == None: self.__setOutput()
402                  front_mask=whereZero(x[1]-inf(x[1]))            return self.__value_of_constraint
403                  if self.front[0]: self._location_of_constraint+=front_mask*[1.,0.,0.]          
404                  if self.front[1]: self._location_of_constraint+=front_mask*[0.,1.,0.]        def __setOutput(self):
405                  if self.front[2]: self._location_of_constraint+=front_mask*[0.,0.,1.]            x=self.domain.getX()
406                  back_mask=whereZero(x[1]-sup(x[1]))            self.__location_of_constraint=Vector(0,x.getFunctionSpace())
407                  if self.back[0]: self._location_of_constraint+=back_mask*[1.,0.,0.]            if self.domain.getDim()==3:
408                  if self.back[1]: self._location_of_constraint+=back_mask*[0.,1.,0.]               x0,x1,x2=x[0],x[1],x[2]
409                  if self.back[2]: self._location_of_constraint+=back_mask*[0.,0.,1.]               left_mask=whereZero(x0-inf(x0),self.tol)
410                  bottom_mask=whereZero(x[2]-inf(x[2]))               if self.left[0]: self.__location_of_constraint+=left_mask*[1.,0.,0.]
411                  if self.bottom[0]: self._location_of_constraint+=bottom_mask*[1.,0.,0.]               if self.left[1]: self.__location_of_constraint+=left_mask*[0.,1.,0.]
412                  if self.bottom[1]: self._location_of_constraint+=bottom_mask*[0.,1.,0.]               if self.left[2]: self.__location_of_constraint+=left_mask*[0.,0.,1.]
413                  if self.bottom[2]: self._location_of_constraint+=bottom_mask*[0.,0.,1.]               right_mask=whereZero(x0-sup(x0),self.tol)
414                  top_mask=whereZero(x[2]-sup(x[2]))               if self.right[0]: self.__location_of_constraint+=right_mask*[1.,0.,0.]
415                  if self.top[0]: self._location_of_constraint+=top_mask*[1.,0.,0.]               if self.right[1]: self.__location_of_constraint+=right_mask*[0.,1.,0.]
416                  if self.top[1]: self._location_of_constraint+=top_mask*[0.,1.,0.]               if self.right[2]: self.__location_of_constraint+=right_mask*[0.,0.,1.]
417                  if self.top[2]: self._location_of_constraint+=top_mask*[0.,0.,1.]               front_mask=whereZero(x1-inf(x1),self.tol)
418               else:               if self.front[0]: self.__location_of_constraint+=front_mask*[1.,0.,0.]
419                  left_mask=whereZero(x[0]-inf(x[0]))               if self.front[1]: self.__location_of_constraint+=front_mask*[0.,1.,0.]
420                  if self.left[0]: self._location_of_constraint+=left_mask*[1.,0.]               if self.front[2]: self.__location_of_constraint+=front_mask*[0.,0.,1.]
421                  if self.left[1]: self._location_of_constraint+=left_mask*[0.,1.]               back_mask=whereZero(x1-sup(x1),self.tol)
422                  right_mask=whereZero(x[0]-sup(x[0]))               if self.back[0]: self.__location_of_constraint+=back_mask*[1.,0.,0.]
423                  if self.right[0]: self._location_of_constraint+=right_mask*[1.,0.]               if self.back[1]: self.__location_of_constraint+=back_mask*[0.,1.,0.]
424                  if self.right[1]: self._location_of_constraint+=right_mask*[0.,1.]               if self.back[2]: self.__location_of_constraint+=back_mask*[0.,0.,1.]
425                  bottom_mask=whereZero(x[1]-inf(x[1]))               bottom_mask=whereZero(x2-inf(x2),self.tol)
426                  if self.bottom[0]: self._location_of_constraint+=bottom_mask*[1.,0.]               if self.bottom[0]: self.__location_of_constraint+=bottom_mask*[1.,0.,0.]
427                  if self.bottom[1]: self._location_of_constraint+=bottom_mask*[0.,1.]               if self.bottom[1]: self.__location_of_constraint+=bottom_mask*[0.,1.,0.]
428                  top_mask=whereZero(x[1]-sup(x[1]))               if self.bottom[2]: self.__location_of_constraint+=bottom_mask*[0.,0.,1.]
429                  if self.top[0]: self._location_of_constraint+=top_mask*[1.,0.]               top_mask=whereZero(x2-sup(x2),self.tol)
430                  if self.top[1]: self._location_of_constraint+=top_mask*[0.,1.]               if self.top[0]: self.__location_of_constraint+=top_mask*[1.,0.,0.]
431            return self._location_of_constraint               if self.top[1]: self.__location_of_constraint+=top_mask*[0.,1.,0.]
432                 if self.top[2]: self.__location_of_constraint+=top_mask*[0.,0.,1.]
433                 if self.value:
434                    self.__value_of_constraint=self.__location_of_constraint*self.value
435              else:
436                 x0,x1=x[0],x[1]
437                 left_mask=whereZero(x0-inf(x0),self.tol)
438                 if self.left[0]: self.__location_of_constraint+=left_mask*[1.,0.]
439                 if self.left[1]: self.__location_of_constraint+=left_mask*[0.,1.]
440                 right_mask=whereZero(x0-sup(x0),self.tol)
441                 if self.right[0]: self.__location_of_constraint+=right_mask*[1.,0.]
442                 if self.right[1]: self.__location_of_constraint+=right_mask*[0.,1.]
443                 bottom_mask=whereZero(x1-inf(x1),self.tol)
444                 if self.bottom[0]: self.__location_of_constraint+=bottom_mask*[1.,0.]
445                 if self.bottom[1]: self.__location_of_constraint+=bottom_mask*[0.,1.]
446                 top_mask=whereZero(x1-sup(x1),self.tol)
447                 if self.top[0]: self.__location_of_constraint+=top_mask*[1.,0.]
448                 if self.top[1]: self.__location_of_constraint+=top_mask*[0.,1.]
449                 if self.value:
450                    self.__value_of_constraint=self.__location_of_constraint*self.value[:2]
451    
452  # vim: expandtab shiftwidth=4:  # vim: expandtab shiftwidth=4:

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

  ViewVC Help
Powered by ViewVC 1.1.26