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

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

  ViewVC Help
Powered by ViewVC 1.1.26