/[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 406 by gross, Fri Dec 23 00:39:59 2005 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             x=self.domain.getX()             super(UpdateGeometry, self).__init__(**kwargs)
155             d=self.domain.getDim()             self.declareParameter(domain=None,\
156             self.location_constrained_value=0                                   displacement=None)
157             x0=x[0]  
158             if self.left:  
159                 self.location_constrained_value=self.location_constrained_value+whereZero(x0-inf(x0))        def doInitialization(self):
160             if self.right:           """
161                 self.location_constrained_value=self.location_constrained_value+whereZero(x0-sup(x0))           initialize model
162             x0=x[d-1]           """
163             if self.buttom:           self.__x=self.domain.getX()
164                 self.location_constrained_value=self.location_constrained_value+whereZero(x0-inf(x0))           self.__reset=True
165             if self.top:          
166                 self.location_constrained_value=self.location_constrained_value+whereZero(x0-sup(x0))        def doStepPreprocessing(self,dt):
167             if d>2:           """
168                x0=x[1]           applies the current L{displacement} to mesh nodes if required.
169                if self.front:           """
170                   self.location_constrained_value=self.location_constrained_value+whereZero(x0-inf(x0))           if self.__reset:
171                if self.back:              self.trace("mesh nodes updated.")
172                   self.location_constrained_value=self.location_constrained_value+whereZero(x0-sup(x0))                        self.domain.setX(self.__x+self.displacement)
173             self.constrain_value=self.value*self.location_constrained_value           self.__reset=False
174              
175  class ScalarConstrainer(ParameterSet):        def doStep(self,dt):
176       """           """
177       Creates a characteristic function for the location of constraints           applies the current L{displacement} to mesh nodes.
178       for a scalar value.           """
179             self.trace("mesh nodes updated.")
180       In the case that the spatial dimension is two, the arguments front           self.domain.setX(self.__x+self.displacement)
181       and back are ignored.           self.__reset=True
182    
183       @ivar domain (in): rectangular domain        def doStepPostprocessing(self,dt):
184       @ivar left (in): True to set a constraint at the left face of the           """
185                 domain (x[0]=min x[0]), default is False           marks nodes as beeing updated.
186       @ivar right (in): True to set a constraint at the left face of the           """
187                 domain (x[0]=max x[0]), default is False           self.__reset=False
188       @ivar top (in): True to set a constraint at the left face of the  
189                 domain (x[1]=min x[1]), default is False  class ConstrainerOverBox(Model):
190       @ivar bottom (in): True to set a constraint at the left face of the        """
191                 domain (x[1]=max x[1]), default is False        Creates a characteristic function for the location of constraints
192       @ivar front (in): True to set a constraint at the left face of the        for all components of a value and selects the value from an initial value
193                 domain (x[2]=min x[2]), default is False        ate these locations.
194       @ivar back (in): True to set a constraint at the left face of the  
195                 domain (x[2]=max x[2]), default is False        In the case that the spatial dimension is two, the arguments front and back are ignored.
196       @ivar location_of_constraint (out): object that defines the location  
197                 of the constraints.        @ivar domain: domain (in).
198       """        @ivar left:  True to set a constraint at the left face of the domain (x[0]=min x[0]), default False (in).
199       def __init__(self,debug=False):        @ivar right: True to set a constraint at the left face of the domain (x[0]=max x[0]), default False (in).
200             ParameterSet.__init__(self,debug=debug)        @ivar top: True to set a constraint at the left face of the domain (x[1]=min x[1]), default False (in).
201          @ivar bottom: True to set a constraint at the left face of the domain (x[1]=max x[1]), default False (in).
202          @ivar front: True to set a constraint at the left face of the domain (x[2]=min x[2]), default False (in).
203          @ivar back: True to set a constraint at the left face of the domain (x[2]=max x[2]), default False (in).
204          @ivar tol: absolute tolerance for "x=max x" condition, default 1.e-8 (in).
205          """
206          def __init__(self,**kwargs):
207               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.406  
changed lines
  Added in v.997

  ViewVC Help
Powered by ViewVC 1.1.26