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

Legend:
Removed from v.406  
changed lines
  Added in v.911

  ViewVC Help
Powered by ViewVC 1.1.26