/[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 938 by gross, Thu Jan 25 03:40:54 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
# Line 7  from esys import finley Line 13  from esys import finley
13    
14  class FinleyReader(ParameterSet):  class FinleyReader(ParameterSet):
15         """         """
16         Generates a mesh over a rectangular domain finley.         reads finley mesh file.
17    
18         @ivar filename:         @ivar source: mesh file in finley or gmsh format
19         @ivar intergrationOrder         @type source: C{DataSource}
20         @ivar domain:         @ivar intergrationOrder: integration order, default -1 (in).
21           @type intergrationOrder: C{int}
22           @ivar reducedIntegrationOrder: reduced integration order, default -1 (in).
23           @type reducedIntegrationOrder: C{int}
24           @ivar optimizeLabeling: switches on optimization of the labeling of the nodes
25           @type optimizeLabeling: C{bool}
26         """         """
27         def __init__(self,debug=False):         def __init__(self,**kwargs):
28             super(FinleyReader,self).__init__(debug=debug)            """
29             ParameterSet.__init__(self,debug=debug)            initializes the object
30             self.declareParameter(source="none",\            """
31                                   integrationOrder=-1)            super(FinleyReader,self).__init__(**kwargs)
32             self._domain=None            self.declareParameter(source="none",
33                                    optimizeLabeling=True,
34                                    reducedIntegrationOrder=-1,
35                                    integrationOrder=-1)
36              self.__domain=None
37    
38         def domain(self):         def domain(self):
39            if self._domain==None:            """
40                self._domain=finley.ReadMesh(self.source,self.integrationOrder)            returns the domain
41                self.trace("mesh read from %s"%self.source)            
42            return self._domain            @return: the domain
43              @rtype: L{Domain}
44              """
45              if self.__domain == None:
46                 if  self.source.fileformat == "fly":
47                    self.__domain=finley.ReadMesh(self.source.getLocalFileName(),self.integrationOrder)
48                 elif self.source.fileformat == "gmsh":
49                    self.__domain=finley.ReadGmsh(self.source.getLocalFileName(),self.integrationOrder,self.reducedIntegrationOrder, self.optimizeLabeling)
50                 else:
51                    raise TypeError("unknown mesh file format %s."%self.source.fileformat)
52                 self.trace("mesh read from %s"%self.source)          
53              return self.__domain
54              
55                                                
56  class RectangularDomain(ParameterSet):  class RectangularDomain(ParameterSet):
57         """         """
58         Generates a mesh over a rectangular domain finley.         Generates a mesh over a rectangular domain finley.
59    
60         @ivar dim:         @ivar dim: spatial dimension, default =2 (in).
61         @ivar l:         @type dim: spatial dimension
62         @ivar n:         @ivar l: spatial lengths, default [1.,1.,1.] (in).
63         @ivar order:         @type l: C{list} of C{floats}s
64         @ivar periodic:         @ivar n: number of elements, default [10,10,10] (in).
65         @ivar intergration order:         @type n: C{list} of C{int}s
66         @ivar domain:         @ivar order: element order, default 1 (in).
67           @type order: C{int}
68           @ivar periodic: flags for periodicity, default [False,False,False] (in).
69           @type periodic: C{list} of C{bool}s
70           @ivar intergrationOrder: integration order, default -1 (in).
71           @type intergrationOrder: C{int}
72         """         """
73         def __init__(self,debug=False):         def __init__(self,**kwargs):
74             super(RectangularDomain,self).__init__(debug=debug)             """
75               initializes the object
76               """
77               super(RectangularDomain,self).__init__(**kwargs)
78             self.declareParameter(dim=2,\             self.declareParameter(dim=2,\
79                                   l=[1.,1.,1.],\                                   l=[1.,1.,1.],\
80                                   n=[10,10,10], \                                   n=[10,10,10], \
81                   order=1,\                   order=1,\
82                                   periodic=[False,False,False],\                                   periodic=[False,False,False],
83                                   integrationOrder=-1)                                   integrationOrder=-1)
84             self._domain=None             self.__domain=None
85    
86         def domain(self):         def domain(self):
87            if self._domain==None:             """
88               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)  
89    
90            return self._domain             @return: the domain
91               @rtype: L{Domain}
92               """
93               if self.__domain==None:
94                  if self.dim==2:
95                       self.__domain=finley.Rectangle(n0=self.n[0],\
96                                                    n1=self.n[1],\
97                                                    l0=self.l[0],\
98                                                    l1=self.l[1],\
99                                                    order=self.order, \
100                                                    periodic0=self.periodic[0], \
101                                                    periodic1=self.periodic[1], \
102                                                    integrationOrder=self.integrationOrder)
103                  else:
104                       self.__domain=finley.Brick(n0=self.n[0],\
105                                                n1=self.n[1],\
106                                                n2=self.n[2],\
107                                                l0=self.l[0],\
108                                                l1=self.l[1],\
109                                                l2=self.l[2],\
110                                                order=self.order, \
111                                                periodic0=self.periodic[0], \
112                                                periodic1=self.periodic[1], \
113                                                periodic2=self.periodic[2], \
114                                                integrationOrder=self.integrationOrder)
115               return self.__domain
116    
117  class ConstrainValue(Model):  class UpdateGeometry(Model):
118         """        """
119         selects values for a given distribution to be used as a constrain. the location of the        applies a displacement field to a domain
120         constrain are he faces of a rectangular domain. This Model is typically used in        
121         time dependend problems to fix the values in a given initial condition.        @ivar displacement: displacements applied to the original mesh coordinates (in).
122         """        @type displacement: L{escript.Vector}
123         def __init__(self,debug=False):        @ivar domain: domain
124             Model.__init__(self,debug=debug)        @type domain: L{escript.Domain}
125             self.declareParameter(domain=None, \        """
126                                   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):  
127             """             """
128             initialize time stepping             set-up the object
129             """             """
130             tol=1.e-8             super(UpdateGeometry, self).__init__(**kwargs)
131             x=self.domain.getX()             self.declareParameter(domain=None,\
132             d=self.domain.getDim()                                   displacement=None)
133             self.location_constrained_value=0  
134             x0=x[0]  
135             mx=sup(x0)        def doInitialization(self):
136             mn=inf(x0)           """
137             if self.left:           initialize model
138                 self.location_constrained_value=self.location_constrained_value+whereZero(x0-mn,tol*(mx-mn))           """
139             if self.right:           self.__x=self.domain.getX()
140                 self.location_constrained_value=self.location_constrained_value+whereZero(x0-mx,tol*(mx-mn))           self.__reset=True
141             x0=x[d-1]          
142             mx=sup(x0)        def doStepPreprocessing(self,dt):
143             mn=inf(x0)           """
144             if self.bottom:           applies the current L{displacement} to mesh nodes if required.
145                 self.location_constrained_value=self.location_constrained_value+whereZero(x0-mn,tol*(mx-mn))           """
146             if self.top:           if self.__reset:
147                 self.location_constrained_value=self.location_constrained_value+whereZero(x0-mx,tol*(mx-mn))              self.trace("mesh nodes updated.")
148             if d>2:              self.domain.setX(self.__x+self.displacement)
149                x0=x[1]           self.__reset=False
150                mx=sup(x0)  
151                mn=inf(x0)        def doStep(self,dt):
152                if self.front:           """
153                   self.location_constrained_value=self.location_constrained_value+whereZero(x0-mn,tol*(mx-mn))           applies the current L{displacement} to mesh nodes.
154                if self.back:           """
155                   self.location_constrained_value=self.location_constrained_value+whereZero(x0-mx,tol*(mx-mn))                     self.trace("mesh nodes updated.")
156             self.constrain_value=self.value*self.location_constrained_value           self.domain.setX(self.__x+self.displacement)
157                       self.__reset=True
158  class ScalarConstrainer(ParameterSet):  
159       """        def doStepPostprocessing(self,dt):
160       Creates a characteristic function for the location of constraints           """
161       for a scalar value.           marks nodes as beeing updated.
162             """
163       In the case that the spatial dimension is two, the arguments front           self.__reset=False
164       and back are ignored.  
165    class ScalarConstrainerOverBox(Model):
166       @ivar domain (in): rectangular domain        """
167       @ivar left (in): True to set a constraint at the left face of the        Creates a characteristic function for the location of constraints
168                 domain (x[0]=min x[0]), default is False        for a scalar value and selects the value from an initial value
169       @ivar right (in): True to set a constraint at the left face of the        ate these locations.
170                 domain (x[0]=max x[0]), default is False  
171       @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.
172                 domain (x[1]=min x[1]), default is False  
173       @ivar bottom (in): True to set a constraint at the left face of the        @ivar domain: domain (in).
174                 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).
175       @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).
176                 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).
177       @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).
178                 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).
179       @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).
180                 of the constraints.        @ivar tol: absolute tolerance for "x=max x" condition, default 1.e-8 (in).
181       """        """
182       def __init__(self,debug=False):        def __init__(self,**kwargs):
183             ParameterSet.__init__(self,debug=debug)             super(ScalarConstrainerOverBox, self).__init__(**kwargs)
184             self.declareParameter(domain=None, \             self.declareParameter(domain=None, \
185                                     value=None,  \
186                                   left=False, \                                   left=False, \
187                                   right=False, \                                   right=False, \
188                                   top=False, \                                   top=False, \
189                                   bottom=False, \                                   bottom=False, \
190                                   front=False, \                                   front=False, \
191                                   back=False)                                   back=False, \
192             self._location_of_constraint=None                                   tol=1.e-8)
193               self.__value_of_constraint = None
194               self.__location_of_constraint=None
195          def location_of_constraint(self):
196              """
197              return the values used to constrain a solution
198    
199       def location_of_constraint(self):            @return: the mask marking the locations of the constraints
200              @rtype: L{escript.Scalar}
201            """            """
202            Returns the mask of the location of constraint.            if self.__location_of_constraint == None: self.__setOutput()
203              return self.__location_of_constraint
204            
205          def value_of_constraint(self):
206            """            """
207            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  
   
 class VectorConstrainer(ParameterSet):  
       """  
       Creates a characteristic function for the location of constraints  
       for a scalar value.  
208    
209        @ivar domain (in): rectangular domain            @return: values to be used at the locations of the constraints. If
210        @ivar left (in): list of three boolean. left[i]==True sets a                    L{value} is not given C{None} is rerturned.
211                  constraint for the i-th component at the left            @rtype: L{escript.Scalar}
212                  face of the domain (x[0]=min x[0]),            """
213                  default is [False,False,False]            if self.__location_of_constraint == None: self.__setOutput()
214        @ivar right (in): list of three boolean. left[i]==True sets a            return self.__value_of_constraint
215                  constraint for the i-th component at the right          
216                  face of the domain (x[0]=max x[0]),        def __setOutput(self):
217                  default is [False,False,False]            x=self.domain.getX()
218        @ivar top (in): list of three boolean. left[i]==True sets a            self.__location_of_constraint=Scalar(0,x.getFunctionSpace())
219                  constraint for the i-th component at the top            if self.domain.getDim()==3:
220                  face of the domain (x[1]=min x[1]),                  x0,x1,x2=x[0],x[1],x[2]
221                  default is [False,False,False]                  if self.left: self.__location_of_constraint+=whereZero(x0-inf(x0),self.tol)
222        @ivar bottom (in): list of three boolean. left[i]==True sets a                  if self.right: self.__location_of_constraint+=whereZero(x0-sup(x0),self.tol)
223                  constraint for the i-th component at the bottom                  if self.front: self.__location_of_constraint+=whereZero(x1-inf(x1),self.tol)
224                  face of the domain (x[1]=min x[1]),                  if self.back: self.__location_of_constraint+=whereZero(x1-sup(x1),self.tol)
225                  default is [False,False,False]                  if self.bottom: self.__location_of_constraint+=whereZero(x2-inf(x2),self.tol)
226        @ivar front (in): list of three boolean. left[i]==True sets a                  if self.top: self.__location_of_constraint+=whereZero(x2-sup(x2),self.tol)
227                  constraint for the i-th component at the front            else:
228                  face of the domain (x[2]=min x[2]),                  x0,x1=x[0],x[1]
229                  default is [False,False,False]                  if self.left: self.__location_of_constraint+=whereZero(x0-inf(x0),self.tol)
230        @ivar back (in): list of three boolean. left[i]==True sets a                  if self.right: self.__location_of_constraint+=whereZero(x0-sup(x0),self.tol)
231                  constraint for the i-th component at the back                  if self.bottom: self.__location_of_constraint+=whereZero(x1-inf(x1),self.tol)
232                  face of the domain (x[2]=max x[2]),                  if self.top: self.__location_of_constraint+=whereZero(x1-sup(x1),self.tol)
233                  default is [False,False,False]            if self.value:
234        @ivar location_of_constraint (callable): object that defines the location of the constraints for each vector component.                self.__value_of_constraint=self.__location_of_constraint*self.value
235    
236        In the case that the spatial dimension is two, thh arguments front and  class VectorConstrainerOverBox(Model):
237          """
238          Creates a characteristic function for the location of constraints vector value.
239          In the case that the spatial dimension is two, the arguments front and
240        back as well as the third component of each argument is ignored.        back as well as the third component of each argument is ignored.
241    
242          @ivar domain: domain
243          @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]),
244                           default [False,False,False] (in).
245          @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]),
246                    default [False,False,False] (in).
247          @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]),
248                    default [False,False,False] (in).
249          @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]),
250                    default [False,False,False] (in).
251          @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]),
252                    default [False,False,False] (in).
253          @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]),
254                    default [False,False,False] (in).
255          @ivar tol: absolute tolerance for "x=max x" condition, default 1.e-8 (in).
256        """        """
257        def __init__(self,debug=False):        def __init__(self, **kwargs):
258             ParameterSet.__init__(self,debug=debug)             super(VectorConstrainerOverBox, self).__init__(**kwargs)
259             self.declareParameter(domain=None, \             self.declareParameter(domain=None, \
260                                     value=None,  \
261                                   left=[0,0,0],  \                                   left=[0,0,0],  \
262                                   right=[0,0,0],  \                                   right=[0,0,0],  \
263                                   top=[0,0,0],  \                                   top=[0,0,0],  \
264                                   bottom=[0,0,0],  \                                   bottom=[0,0,0],  \
265                                   front=[0,0,0],                                   front=[0,0,0], \
266                                   back=[0,0,0])                                   back=[0,0,0], \
267             self._location_of_constraint=None                                   tol=1.e-8)
268               self.__value_of_constraint = None
269               self.__location_of_constraint=None
270    
271        def location_of_constraint(self):        def location_of_constraint(self):
272            """            """
273            Returns the mask of the location of constraint.            return the values used to constrain a solution
274    
275              @return: the mask marking the locations of the constraints
276              @rtype: L{escript.Vector}
277            """            """
278            if self._location_of_constraint==None:            if self.__location_of_constraint == None: self.__setOutput()
279               x=self.domain.getX()            return self.__location_of_constraint
280               self._location_of_constraint=Vector(0,x.getFunctionSpace())          
281               if self.domain.getDim()==3:        def value_of_constraint(self):
282                  left_mask=whereZero(x[0]-inf(x[0]))            """
283                  if self.left[0]: self._location_of_constraint+=left_mask*[1.,0.,0.]            return the values used to constrain a solution
284                  if self.left[1]: self._location_of_constraint+=left_mask*[0.,1.,0.]  
285                  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
286                  right_mask=whereZero(x[0]-sup(x[0]))                    L{value} is not given C{None} is rerturned.
287                  if self.right[0]: self._location_of_constraint+=right_mask*[1.,0.,0.]            @rtype: L{escript.Vector}
288                  if self.right[1]: self._location_of_constraint+=right_mask*[0.,1.,0.]            """
289                  if self.right[2]: self._location_of_constraint+=right_mask*[0.,0.,1.]            if self.__location_of_constraint == None: self.__setOutput()
290                  front_mask=whereZero(x[1]-inf(x[1]))            return self.__value_of_constraint
291                  if self.front[0]: self._location_of_constraint+=front_mask*[1.,0.,0.]          
292                  if self.front[1]: self._location_of_constraint+=front_mask*[0.,1.,0.]        def __setOutput(self):
293                  if self.front[2]: self._location_of_constraint+=front_mask*[0.,0.,1.]            x=self.domain.getX()
294                  back_mask=whereZero(x[1]-sup(x[1]))            self.__location_of_constraint=Vector(0,x.getFunctionSpace())
295                  if self.back[0]: self._location_of_constraint+=back_mask*[1.,0.,0.]            if self.domain.getDim()==3:
296                  if self.back[1]: self._location_of_constraint+=back_mask*[0.,1.,0.]               x0,x1,x2=x[0],x[1],x[2]
297                  if self.back[2]: self._location_of_constraint+=back_mask*[0.,0.,1.]               left_mask=whereZero(x0-inf(x0),self.tol)
298                  bottom_mask=whereZero(x[2]-inf(x[2]))               if self.left[0]: self.__location_of_constraint+=left_mask*[1.,0.,0.]
299                  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.]
300                  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.]
301                  if self.bottom[2]: self._location_of_constraint+=bottom_mask*[0.,0.,1.]               right_mask=whereZero(x0-sup(x0),self.tol)
302                  top_mask=whereZero(x[2]-sup(x[2]))               if self.right[0]: self.__location_of_constraint+=right_mask*[1.,0.,0.]
303                  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.]
304                  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.]
305                  if self.top[2]: self._location_of_constraint+=top_mask*[0.,0.,1.]               front_mask=whereZero(x1-inf(x1),self.tol)
306               else:               if self.front[0]: self.__location_of_constraint+=front_mask*[1.,0.,0.]
307                  left_mask=whereZero(x[0]-inf(x[0]))               if self.front[1]: self.__location_of_constraint+=front_mask*[0.,1.,0.]
308                  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.]
309                  if self.left[1]: self._location_of_constraint+=left_mask*[0.,1.]               back_mask=whereZero(x1-sup(x1),self.tol)
310                  right_mask=whereZero(x[0]-sup(x[0]))               if self.back[0]: self.__location_of_constraint+=back_mask*[1.,0.,0.]
311                  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.]
312                  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.]
313                  bottom_mask=whereZero(x[1]-inf(x[1]))               bottom_mask=whereZero(x2-inf(x2),self.tol)
314                  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.]
315                  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.]
316                  top_mask=whereZero(x[1]-sup(x[1]))               if self.bottom[2]: self.__location_of_constraint+=bottom_mask*[0.,0.,1.]
317                  if self.top[0]: self._location_of_constraint+=top_mask*[1.,0.]               top_mask=whereZero(x2-sup(x2),self.tol)
318                  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.]
319            return self._location_of_constraint               if self.top[1]: self.__location_of_constraint+=top_mask*[0.,1.,0.]
320                 if self.top[2]: self.__location_of_constraint+=top_mask*[0.,0.,1.]
321                 if self.value:
322                    self.__value_of_constraint=self.__location_of_constraint*self.value
323              else:
324                 x0,x1=x[0],x[1]
325                 left_mask=whereZero(x0-inf(x0),self.tol)
326                 if self.left[0]: self.__location_of_constraint+=left_mask*[1.,0.]
327                 if self.left[1]: self.__location_of_constraint+=left_mask*[0.,1.]
328                 right_mask=whereZero(x0-sup(x0),self.tol)
329                 if self.right[0]: self.__location_of_constraint+=right_mask*[1.,0.]
330                 if self.right[1]: self.__location_of_constraint+=right_mask*[0.,1.]
331                 bottom_mask=whereZero(x1-inf(x1),self.tol)
332                 if self.bottom[0]: self.__location_of_constraint+=bottom_mask*[1.,0.]
333                 if self.bottom[1]: self.__location_of_constraint+=bottom_mask*[0.,1.]
334                 top_mask=whereZero(x1-sup(x1),self.tol)
335                 if self.top[0]: self.__location_of_constraint+=top_mask*[1.,0.]
336                 if self.top[1]: self.__location_of_constraint+=top_mask*[0.,1.]
337                 if self.value:
338                    self.__value_of_constraint=self.__location_of_constraint*self.value[:2]
339    
340  # vim: expandtab shiftwidth=4:  # vim: expandtab shiftwidth=4:

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

  ViewVC Help
Powered by ViewVC 1.1.26