/[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 1152 by gross, Thu May 17 04:46:04 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                                    dim=None,
34                                    optimizeLabeling=True,
35                                    reducedIntegrationOrder=-1,
36                                    integrationOrder=-1)
37              self.__domain=None
38    
39    
40         def domain(self):         def domain(self):
41            if self._domain==None:            """
42                self._domain=finley.ReadMesh(self.source,self.integrationOrder)            returns the domain
43                self.trace("mesh read from %s"%self.source)            
44            return self._domain            @return: the domain
45                                    @rtype: L{Domain}
46              """
47              if self.__domain == None:
48                 if  self.source.fileformat == "fly":
49                    self.__domain=finley.ReadMesh(self.source.getLocalFileName(),self.integrationOrder)
50                 elif self.source.fileformat == "gmsh":
51                    if self.dim==None:
52                       dim=3
53                    else:
54                       dim=self.dim
55                    self.__domain=finley.ReadGmsh(self.source.getLocalFileName(),dim,self.integrationOrder,self.reducedIntegrationOrder, self.optimizeLabeling)
56                 else:
57                    raise TypeError("unknown mesh file format %s."%self.source.fileformat)
58                 self.trace("mesh read from %s in %s format."%(self.source.getLocalFileName(), self.source.fileformat))          
59              return self.__domain
60  class RectangularDomain(ParameterSet):  class RectangularDomain(ParameterSet):
61         """         """
62         Generates a mesh over a rectangular domain finley.         Generates a mesh over a rectangular domain finley.
63    
64         @ivar dim:         @ivar dim: spatial dimension, default =2 (in).
65         @ivar l:         @type dim: spatial dimension
66         @ivar n:         @ivar l: spatial lengths, default [1.,1.,1.] (in).
67         @ivar order:         @type l: C{list} of C{floats}s
68         @ivar periodic:         @ivar n: number of elements, default [10,10,10] (in).
69         @ivar intergration order:         @type n: C{list} of C{int}s
70         @ivar domain:         @ivar order: element order, default 1 (in).
71           @type order: C{int}
72           @ivar periodic: flags for periodicity, default [False,False,False] (in).
73           @type periodic: C{list} of C{bool}s
74           @ivar intergrationOrder: integration order, default -1 (in).
75           @type intergrationOrder: C{int}
76         """         """
77         def __init__(self,debug=False):         def __init__(self,**kwargs):
78             super(RectangularDomain,self).__init__(debug=debug)             """
79               initializes the object
80               """
81               super(RectangularDomain,self).__init__(**kwargs)
82             self.declareParameter(dim=2,\             self.declareParameter(dim=2,\
83                                   l=[1.,1.,1.],\                                   l=[1.,1.,1.],\
84                                   n=[10,10,10], \                                   n=[10,10,10], \
85                   order=1,\                   order=1,\
86                                   periodic=[False,False,False],\                                   periodic=[False,False,False],
87                                   integrationOrder=-1)                                   integrationOrder=-1)
88             self._domain=None             self.__domain=None
89    
90         def domain(self):         def domain(self):
91            if self._domain==None:             """
92               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)  
93    
94            return self._domain             @return: the domain
95               @rtype: L{Domain}
96               """
97               if self.__domain==None:
98                  if self.dim==2:
99                       self.__domain=finley.Rectangle(n0=self.n[0],\
100                                                    n1=self.n[2],\
101                                                    l0=self.l[0],\
102                                                    l1=self.l[2],\
103                                                    order=self.order, \
104                                                    periodic0=self.periodic[0], \
105                                                    periodic1=self.periodic[2], \
106                                                    integrationOrder=self.integrationOrder)
107                  else:
108                       self.__domain=finley.Brick(n0=self.n[0],\
109                                                n1=self.n[1],\
110                                                n2=self.n[2],\
111                                                l0=self.l[0],\
112                                                l1=self.l[1],\
113                                                l2=self.l[2],\
114                                                order=self.order, \
115                                                periodic0=self.periodic[0], \
116                                                periodic1=self.periodic[1], \
117                                                periodic2=self.periodic[2], \
118                                                integrationOrder=self.integrationOrder)
119               return self.__domain
120    
121  class ConstrainValue(Model):  class UpdateGeometry(Model):
122         """        """
123         selects values for a given distribution to be used as a constrain. the location of the        applies a displacement field to a domain
124         constrain are he faces of a rectangular domain. This Model is typically used in        
125         time dependend problems to fix the values in a given initial condition.        @ivar displacement: displacements applied to the original mesh coordinates (in).
126         """        @type displacement: L{escript.Vector}
127         def __init__(self,debug=False):        @ivar domain: domain
128             Model.__init__(self,debug=debug)        @type domain: L{escript.Domain}
129             self.declareParameter(domain=None, \        """
130                                   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):  
131             """             """
132             initialize time stepping             set-up the object
133             """             """
134             tol=1.e-8             super(UpdateGeometry, self).__init__(**kwargs)
135             x=self.domain.getX()             self.declareParameter(domain=None,\
136             d=self.domain.getDim()                                   displacement=None)
137             self.location_constrained_value=0  
138             x0=x[0]  
139             mx=sup(x0)        def doInitialization(self):
140             mn=inf(x0)           """
141             if self.left:           initialize model
142                 self.location_constrained_value=self.location_constrained_value+whereZero(x0-mn,tol*(mx-mn))           """
143             if self.right:           self.__x=self.domain.getX()
144                 self.location_constrained_value=self.location_constrained_value+whereZero(x0-mx,tol*(mx-mn))           self.__reset=True
145             x0=x[d-1]          
146             mx=sup(x0)        def doStepPreprocessing(self,dt):
147             mn=inf(x0)           """
148             if self.bottom:           applies the current L{displacement} to mesh nodes if required.
149                 self.location_constrained_value=self.location_constrained_value+whereZero(x0-mn,tol*(mx-mn))           """
150             if self.top:           if self.__reset:
151                 self.location_constrained_value=self.location_constrained_value+whereZero(x0-mx,tol*(mx-mn))              self.trace("mesh nodes updated.")
152             if d>2:              self.domain.setX(self.__x+self.displacement)
153                x0=x[1]           self.__reset=False
154                mx=sup(x0)  
155                mn=inf(x0)        def doStep(self,dt):
156                if self.front:           """
157                   self.location_constrained_value=self.location_constrained_value+whereZero(x0-mn,tol*(mx-mn))           applies the current L{displacement} to mesh nodes.
158                if self.back:           """
159                   self.location_constrained_value=self.location_constrained_value+whereZero(x0-mx,tol*(mx-mn))                     self.trace("mesh nodes updated.")
160             self.constrain_value=self.value*self.location_constrained_value           self.domain.setX(self.__x+self.displacement)
161                       self.__reset=True
162  class ScalarConstrainer(ParameterSet):  
163       """        def doStepPostprocessing(self,dt):
164       Creates a characteristic function for the location of constraints           """
165       for a scalar value.           marks nodes as beeing updated.
166             """
167       In the case that the spatial dimension is two, the arguments front           self.__reset=False
168       and back are ignored.  
169    class ConstrainerOverBox(Model):
170       @ivar domain (in): rectangular domain        """
171       @ivar left (in): True to set a constraint at the left face of the        Creates a characteristic function for the location of constraints
172                 domain (x[0]=min x[0]), default is False        for all components of a value and selects the value from an initial value
173       @ivar right (in): True to set a constraint at the left face of the        ate these locations.
174                 domain (x[0]=max x[0]), default is False  
175       @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.
176                 domain (x[1]=min x[1]), default is False  
177       @ivar bottom (in): True to set a constraint at the left face of the        @ivar domain: domain (in).
178                 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).
179       @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).
180                 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).
181       @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).
182                 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).
183       @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).
184                 of the constraints.        @ivar tol: absolute tolerance for "x=max x" condition, default 1.e-8 (in).
185       """        """
186       def __init__(self,debug=False):        def __init__(self,**kwargs):
187             ParameterSet.__init__(self,debug=debug)             super(ConstrainerOverBox, self).__init__(**kwargs)
188             self.declareParameter(domain=None, \             self.declareParameter(domain=None, \
189                                     value=None,  \
190                                   left=False, \                                   left=False, \
191                                   right=False, \                                   right=False, \
192                                   top=False, \                                   top=False, \
193                                   bottom=False, \                                   bottom=False, \
194                                   front=False, \                                   front=False, \
195                                   back=False)                                   back=False, \
196             self._location_of_constraint=None                                   tol=1.e-8)
197               self.__value_of_constraint = None
198               self.__location_of_constraint=None
199          def location_of_constraint(self):
200              """
201              return the values used to constrain a solution
202    
203       def location_of_constraint(self):            @return: the mask marking the locations of the constraints
204              @rtype: L{escript.Scalar}
205              """
206              if self.__location_of_constraint == None: self.__setOutput()
207              return self.__location_of_constraint
208            
209          def value_of_constraint(self):
210            """            """
211            Returns the mask of the location of constraint.            return the values used to constrain a solution
212    
213              @return: values to be used at the locations of the constraints. If
214                      L{value} is not given C{None} is rerturned.
215              @rtype: L{escript.Scalar}
216            """            """
217            if self._location_of_constraint==None:            if self.__location_of_constraint == None: self.__setOutput()
218              return self.__value_of_constraint
219            
220          def __setOutput(self):
221              if self.__location_of_constraint == None:
222               x=self.domain.getX()               x=self.domain.getX()
223               self._location_of_constraint=Scalar(0,x.getFunctionSpace())               val=self.value
224                 if isinstance(val, int) or isinstance(val, float):
225                    shape=()
226                 elif isinstance(val, list) or isinstance(val, tuple) :
227                    shape=(len(val),)
228                 elif isinstance(val, numarray.NumArray):
229                     shape=val.shape
230                 elif val == None:
231                      shape=()
232                 else:
233                     shape=val.getShape()
234                 self.__location_of_constraint=Data(0,shape,x.getFunctionSpace())
235               if self.domain.getDim()==3:               if self.domain.getDim()==3:
236                  if self.left: self._location_of_constraint+=whereZero(x[0]-inf(x[0]))                     x0,x1,x2=x[0],x[1],x[2]
237                  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)
238                  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)
239                  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)
240                  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)
241                  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)
242                       if self.top: self.__location_of_constraint+=whereZero(x2-sup(x2),self.tol)
243               else:               else:
244                  if self.left: self._location_of_constraint+=whereZero(x[0]-inf(x[0]))                     x0,x1=x[0],x[1]
245                  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)
246                  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)
247                  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)
248            return self._location_of_constraint                     if self.top: self.__location_of_constraint+=whereZero(x1-sup(x1),self.tol)
249                 if not self.value == None:
250  class VectorConstrainer(ParameterSet):                     self.__value_of_constraint=self.__location_of_constraint*self.value
251    class ScalarConstrainerOverBox(Model):
252        """        """
253        Creates a characteristic function for the location of constraints        Creates a characteristic function for the location of constraints
254        for a scalar value.        for a scalar value and selects the value from an initial value
255          ate these locations.
256    
257          In the case that the spatial dimension is two, the arguments front and back are ignored.
258    
259          @ivar domain: domain (in).
260          @ivar left:  True to set a constraint at the left face of the domain (x[0]=min x[0]), default False (in).
261          @ivar right: True to set a constraint at the left face of the domain (x[0]=max x[0]), default False (in).
262          @ivar top: True to set a constraint at the left face of the domain (x[1]=min x[1]), default False (in).
263          @ivar bottom: True to set a constraint at the left face of the domain (x[1]=max x[1]), default False (in).
264          @ivar front: True to set a constraint at the left face of the domain (x[2]=min x[2]), default False (in).
265          @ivar back: True to set a constraint at the left face of the domain (x[2]=max x[2]), default False (in).
266          @ivar tol: absolute tolerance for "x=max x" condition, default 1.e-8 (in).
267          """
268          def __init__(self,**kwargs):
269               super(ScalarConstrainerOverBox, self).__init__(**kwargs)
270               self.declareParameter(domain=None, \
271                                     value=None,  \
272                                     left=False, \
273                                     right=False, \
274                                     top=False, \
275                                     bottom=False, \
276                                     front=False, \
277                                     back=False, \
278                                     tol=1.e-8)
279               self.__value_of_constraint = None
280               self.__location_of_constraint=None
281          def location_of_constraint(self):
282              """
283              return the values used to constrain a solution
284    
285              @return: the mask marking the locations of the constraints
286              @rtype: L{escript.Scalar}
287              """
288              if self.__location_of_constraint == None: self.__setOutput()
289              return self.__location_of_constraint
290            
291          def value_of_constraint(self):
292              """
293              return the values used to constrain a solution
294    
295        @ivar domain (in): rectangular domain            @return: values to be used at the locations of the constraints. If
296        @ivar left (in): list of three boolean. left[i]==True sets a                    L{value} is not given C{None} is rerturned.
297                  constraint for the i-th component at the left            @rtype: L{escript.Scalar}
298                  face of the domain (x[0]=min x[0]),            """
299                  default is [False,False,False]            if self.__location_of_constraint == None: self.__setOutput()
300        @ivar right (in): list of three boolean. left[i]==True sets a            return self.__value_of_constraint
301                  constraint for the i-th component at the right          
302                  face of the domain (x[0]=max x[0]),        def __setOutput(self):
303                  default is [False,False,False]            x=self.domain.getX()
304        @ivar top (in): list of three boolean. left[i]==True sets a            self.__location_of_constraint=Scalar(0,x.getFunctionSpace())
305                  constraint for the i-th component at the top            if self.domain.getDim()==3:
306                  face of the domain (x[1]=min x[1]),                  x0,x1,x2=x[0],x[1],x[2]
307                  default is [False,False,False]                  if self.left: self.__location_of_constraint+=whereZero(x0-inf(x0),self.tol)
308        @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)
309                  constraint for the i-th component at the bottom                  if self.front: self.__location_of_constraint+=whereZero(x1-inf(x1),self.tol)
310                  face of the domain (x[1]=min x[1]),                  if self.back: self.__location_of_constraint+=whereZero(x1-sup(x1),self.tol)
311                  default is [False,False,False]                  if self.bottom: self.__location_of_constraint+=whereZero(x2-inf(x2),self.tol)
312        @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)
313                  constraint for the i-th component at the front            else:
314                  face of the domain (x[2]=min x[2]),                  x0,x1=x[0],x[1]
315                  default is [False,False,False]                  if self.left: self.__location_of_constraint+=whereZero(x0-inf(x0),self.tol)
316        @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)
317                  constraint for the i-th component at the back                  if self.bottom: self.__location_of_constraint+=whereZero(x1-inf(x1),self.tol)
318                  face of the domain (x[2]=max x[2]),                  if self.top: self.__location_of_constraint+=whereZero(x1-sup(x1),self.tol)
319                  default is [False,False,False]            if not self.value == None:
320        @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
321    
322        In the case that the spatial dimension is two, thh arguments front and  class VectorConstrainerOverBox(Model):
323          """
324          Creates a characteristic function for the location of constraints vector value.
325          In the case that the spatial dimension is two, the arguments front and
326        back as well as the third component of each argument is ignored.        back as well as the third component of each argument is ignored.
327    
328          @ivar domain: domain
329          @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]),
330                           default [False,False,False] (in).
331          @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]),
332                    default [False,False,False] (in).
333          @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]),
334                    default [False,False,False] (in).
335          @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]),
336                    default [False,False,False] (in).
337          @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]),
338                    default [False,False,False] (in).
339          @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]),
340                    default [False,False,False] (in).
341          @ivar tol: absolute tolerance for "x=max x" condition, default 1.e-8 (in).
342          """
343          def __init__(self, **kwargs):
344               super(VectorConstrainerOverBox, self).__init__(**kwargs)
345               self.declareParameter(domain=None, \
346                                     value=None,  \
347                                     left=[False ,False ,False ],  \
348                                     right=[False ,False ,False ],  \
349                                     top=[False ,False ,False ],  \
350                                     bottom=[False ,False ,False ],  \
351                                     front=[False ,False ,False ], \
352                                     back=[False ,False ,False ], \
353                                     tol=1.e-8)
354               self.__value_of_constraint = None
355               self.__location_of_constraint=None
356    
357          def location_of_constraint(self):
358              """
359              return the values used to constrain a solution
360    
361              @return: the mask marking the locations of the constraints
362              @rtype: L{escript.Vector}
363              """
364              if self.__location_of_constraint == None: self.__setOutput()
365              return self.__location_of_constraint
366            
367          def value_of_constraint(self):
368              """
369              return the values used to constrain a solution
370    
371              @return: values to be used at the locations of the constraints. If
372                      L{value} is not given C{None} is rerturned.
373              @rtype: L{escript.Vector}
374              """
375              if self.__location_of_constraint == None: self.__setOutput()
376              return self.__value_of_constraint
377            
378          def __setOutput(self):
379              x=self.domain.getX()
380              self.__location_of_constraint=Vector(0,x.getFunctionSpace())
381              if self.domain.getDim()==3:
382                 x0,x1,x2=x[0],x[1],x[2]
383                 left_mask=whereZero(x0-inf(x0),self.tol)
384                 if self.left[0]: self.__location_of_constraint+=left_mask*[1.,0.,0.]
385                 if self.left[1]: self.__location_of_constraint+=left_mask*[0.,1.,0.]
386                 if self.left[2]: self.__location_of_constraint+=left_mask*[0.,0.,1.]
387                 right_mask=whereZero(x0-sup(x0),self.tol)
388                 if self.right[0]: self.__location_of_constraint+=right_mask*[1.,0.,0.]
389                 if self.right[1]: self.__location_of_constraint+=right_mask*[0.,1.,0.]
390                 if self.right[2]: self.__location_of_constraint+=right_mask*[0.,0.,1.]
391                 front_mask=whereZero(x1-inf(x1),self.tol)
392                 if self.front[0]: self.__location_of_constraint+=front_mask*[1.,0.,0.]
393                 if self.front[1]: self.__location_of_constraint+=front_mask*[0.,1.,0.]
394                 if self.front[2]: self.__location_of_constraint+=front_mask*[0.,0.,1.]
395                 back_mask=whereZero(x1-sup(x1),self.tol)
396                 if self.back[0]: self.__location_of_constraint+=back_mask*[1.,0.,0.]
397                 if self.back[1]: self.__location_of_constraint+=back_mask*[0.,1.,0.]
398                 if self.back[2]: self.__location_of_constraint+=back_mask*[0.,0.,1.]
399                 bottom_mask=whereZero(x2-inf(x2),self.tol)
400                 if self.bottom[0]: self.__location_of_constraint+=bottom_mask*[1.,0.,0.]
401                 if self.bottom[1]: self.__location_of_constraint+=bottom_mask*[0.,1.,0.]
402                 if self.bottom[2]: self.__location_of_constraint+=bottom_mask*[0.,0.,1.]
403                 top_mask=whereZero(x2-sup(x2),self.tol)
404                 if self.top[0]: self.__location_of_constraint+=top_mask*[1.,0.,0.]
405                 if self.top[1]: self.__location_of_constraint+=top_mask*[0.,1.,0.]
406                 if self.top[2]: self.__location_of_constraint+=top_mask*[0.,0.,1.]
407                 if not self.value == None:
408                    self.__value_of_constraint=self.__location_of_constraint*self.value
409              else:
410                 x0,x1=x[0],x[1]
411                 left_mask=whereZero(x0-inf(x0),self.tol)
412                 if self.left[0]: self.__location_of_constraint+=left_mask*[1.,0.]
413                 if self.left[1]: self.__location_of_constraint+=left_mask*[0.,1.]
414                 right_mask=whereZero(x0-sup(x0),self.tol)
415                 if self.right[0]: self.__location_of_constraint+=right_mask*[1.,0.]
416                 if self.right[1]: self.__location_of_constraint+=right_mask*[0.,1.]
417                 bottom_mask=whereZero(x1-inf(x1),self.tol)
418                 if self.bottom[0]: self.__location_of_constraint+=bottom_mask*[1.,0.]
419                 if self.bottom[1]: self.__location_of_constraint+=bottom_mask*[0.,1.]
420                 top_mask=whereZero(x1-sup(x1),self.tol)
421                 if self.top[0]: self.__location_of_constraint+=top_mask*[1.,0.]
422                 if self.top[1]: self.__location_of_constraint+=top_mask*[0.,1.]
423                 if not self.value == None:
424                    self.__value_of_constraint=self.__location_of_constraint*self.value[:2]
425    
426    class ConstrainerAtBoxVertex(Model):
427        """        """
428        def __init__(self,debug=False):        Creates a characteristic function for the location of constraints
429             ParameterSet.__init__(self,debug=debug)        for all components of a value and selects the value from an initial value
430          ate these locations.
431    
432          In the case that the spatial dimension is two, the arguments front and back are ignored.
433    
434          @ivar domain: domain (in).
435          @ivar tol: absolute tolerance for "x=left, front, bottom vertex" condition, default 1.e-8 (in).
436          """
437          def __init__(self,**kwargs):
438               super(ConstrainerAtBoxVertex, self).__init__(**kwargs)
439             self.declareParameter(domain=None, \             self.declareParameter(domain=None, \
440                                   left=[0,0,0],  \                                   value=None,  \
441                                   right=[0,0,0],  \                                   tol=1.e-8)
442                                   top=[0,0,0],  \             self.__value_of_constraint = None
443                                   bottom=[0,0,0],  \             self.__location_of_constraint=None
                                  front=[0,0,0],  
                                  back=[0,0,0])  
            self._location_of_constraint=None  
444        def location_of_constraint(self):        def location_of_constraint(self):
445            """            """
446            Returns the mask of the location of constraint.            return the values used to constrain a solution
447    
448              @return: the mask marking the locations of the constraints
449              @rtype: L{escript.Scalar}
450              """
451              if self.__location_of_constraint == None: self.__setOutput()
452              return self.__location_of_constraint
453            
454          def value_of_constraint(self):
455            """            """
456            if self._location_of_constraint==None:            return the values used to constrain a solution
457    
458              @return: values to be used at the locations of the constraints. If
459                      L{value} is not given C{None} is rerturned.
460              @rtype: L{escript.Scalar}
461              """
462              if self.__location_of_constraint == None: self.__setOutput()
463              return self.__value_of_constraint
464            
465          def __setOutput(self):
466              if self.__location_of_constraint == None:
467               x=self.domain.getX()               x=self.domain.getX()
468               self._location_of_constraint=Vector(0,x.getFunctionSpace())               val=self.value
469                 if isinstance(val, int) or isinstance(val, float):
470                    shape=()
471                 elif isinstance(val, list) or isinstance(val, tuple) :
472                    shape=(len(val),)
473                 elif isinstance(val, numarray.NumArray):
474                     shape=val.shape
475                 elif val == None:
476                      shape=()
477                 else:
478                     shape=val.getShape()
479               if self.domain.getDim()==3:               if self.domain.getDim()==3:
480                  left_mask=whereZero(x[0]-inf(x[0]))                     vertex=[inf(x[0]),inf(x[1]),inf(x[2])]
                 if self.left[0]: self._location_of_constraint+=left_mask*[1.,0.,0.]  
                 if self.left[1]: self._location_of_constraint+=left_mask*[0.,1.,0.]  
                 if self.left[2]: self._location_of_constraint+=left_mask*[0.,0.,1.]  
                 right_mask=whereZero(x[0]-sup(x[0]))  
                 if self.right[0]: self._location_of_constraint+=right_mask*[1.,0.,0.]  
                 if self.right[1]: self._location_of_constraint+=right_mask*[0.,1.,0.]  
                 if self.right[2]: self._location_of_constraint+=right_mask*[0.,0.,1.]  
                 front_mask=whereZero(x[1]-inf(x[1]))  
                 if self.front[0]: self._location_of_constraint+=front_mask*[1.,0.,0.]  
                 if self.front[1]: self._location_of_constraint+=front_mask*[0.,1.,0.]  
                 if self.front[2]: self._location_of_constraint+=front_mask*[0.,0.,1.]  
                 back_mask=whereZero(x[1]-sup(x[1]))  
                 if self.back[0]: self._location_of_constraint+=back_mask*[1.,0.,0.]  
                 if self.back[1]: self._location_of_constraint+=back_mask*[0.,1.,0.]  
                 if self.back[2]: self._location_of_constraint+=back_mask*[0.,0.,1.]  
                 bottom_mask=whereZero(x[2]-inf(x[2]))  
                 if self.bottom[0]: self._location_of_constraint+=bottom_mask*[1.,0.,0.]  
                 if self.bottom[1]: self._location_of_constraint+=bottom_mask*[0.,1.,0.]  
                 if self.bottom[2]: self._location_of_constraint+=bottom_mask*[0.,0.,1.]  
                 top_mask=whereZero(x[2]-sup(x[2]))  
                 if self.top[0]: self._location_of_constraint+=top_mask*[1.,0.,0.]  
                 if self.top[1]: self._location_of_constraint+=top_mask*[0.,1.,0.]  
                 if self.top[2]: self._location_of_constraint+=top_mask*[0.,0.,1.]  
481               else:               else:
482                  left_mask=whereZero(x[0]-inf(x[0]))                     vertex=[inf(x[0]),inf(x[1])]
483                  if self.left[0]: self._location_of_constraint+=left_mask*[1.,0.]               self.__location_of_constraint=whereZero(length(x-vertex),self.tol)*numarray.ones(shape)
484                  if self.left[1]: self._location_of_constraint+=left_mask*[0.,1.]               if not self.value == None:
485                  right_mask=whereZero(x[0]-sup(x[0]))                     self.__value_of_constraint=self.__location_of_constraint*self.value
486                  if self.right[0]: self._location_of_constraint+=right_mask*[1.,0.]  class ScalarConstrainerAtBoxVertex(Model):
487                  if self.right[1]: self._location_of_constraint+=right_mask*[0.,1.]        """
488                  bottom_mask=whereZero(x[1]-inf(x[1]))        Creates a characteristic function for the location of constraints
489                  if self.bottom[0]: self._location_of_constraint+=bottom_mask*[1.,0.]        for a scalar value and selects the value from an initial value
490                  if self.bottom[1]: self._location_of_constraint+=bottom_mask*[0.,1.]        ate these locations.
491                  top_mask=whereZero(x[1]-sup(x[1]))  
492                  if self.top[0]: self._location_of_constraint+=top_mask*[1.,0.]        In the case that the spatial dimension is two, the arguments front and back are ignored.
493                  if self.top[1]: self._location_of_constraint+=top_mask*[0.,1.]  
494            return self._location_of_constraint        @ivar domain: domain (in).
495          @ivar tol: absolute tolerance for "x=left, front, bottom vertex" condition, default 1.e-8 (in).
496          """
497          def __init__(self,**kwargs):
498               super(ScalarConstrainerAtBoxVertex, self).__init__(**kwargs)
499               self.declareParameter(domain=None, \
500                                     value=None,  \
501                                     tol=1.e-8)
502               self.__value_of_constraint = None
503               self.__location_of_constraint=None
504          def location_of_constraint(self):
505              """
506              return the values used to constrain a solution
507    
508              @return: the mask marking the locations of the constraints
509              @rtype: L{escript.Scalar}
510              """
511              if self.__location_of_constraint == None: self.__setOutput()
512              return self.__location_of_constraint
513            
514          def value_of_constraint(self):
515              """
516              return the values used to constrain a solution
517    
518              @return: values to be used at the locations of the constraints. If
519                      L{value} is not given C{None} is rerturned.
520              @rtype: L{escript.Scalar}
521              """
522              if self.__location_of_constraint == None: self.__setOutput()
523              return self.__value_of_constraint
524            
525          def __setOutput(self):
526              x=self.domain.getX()
527              self.__location_of_constraint=Scalar(0,x.getFunctionSpace())
528              if self.domain.getDim()==3:
529                       vertex=[inf(x[0]),inf(x[1]),inf(x[2])]
530              else:
531                     vertex=[inf(x[0]),inf(x[1])]
532              self.__location_of_constraint=whereZero(length(x-vertex),self.tol)
533              if not self.value == None:
534                  self.__value_of_constraint=self.__location_of_constraint*self.value
535    
536    class VectorConstrainerAtBoxVertex(Model):
537          """
538          Creates a characteristic function for the location of constraints vector value.
539          In the case that the spatial dimension is two, the arguments front and
540          back as well as the third component of each argument is ignored.
541    
542          @ivar domain: domain
543          @ivar comp_mask: list of three boolean. comp_mask[i]==True sets a constraint for the i-th component at the left, front, bottom vertex, default [False,False,False] (in).
544          @ivar tol: absolute tolerance for "x=left, front, bottom vertex" condition, default 1.e-8 (in).
545          """
546          def __init__(self, **kwargs):
547               super(VectorConstrainerAtBoxVertex, self).__init__(**kwargs)
548               self.declareParameter(domain=None, \
549                                     value=None,  \
550                                     comp_mask=[False, False, False],
551                                     tol=1.e-8)
552               self.__value_of_constraint = None
553               self.__location_of_constraint=None
554    
555          def location_of_constraint(self):
556              """
557              return the values used to constrain a solution
558    
559              @return: the mask marking the locations of the constraints
560              @rtype: L{escript.Vector}
561              """
562              if self.__location_of_constraint == None: self.__setOutput()
563              return self.__location_of_constraint
564            
565          def value_of_constraint(self):
566              """
567              return the values used to constrain a solution
568    
569              @return: values to be used at the locations of the constraints. If
570                      L{value} is not given C{None} is rerturned.
571              @rtype: L{escript.Vector}
572              """
573              if self.__location_of_constraint == None: self.__setOutput()
574              return self.__value_of_constraint
575            
576          def __setOutput(self):
577              x=self.domain.getX()
578              self.__location_of_constraint=Vector(0,x.getFunctionSpace())
579              if self.domain.getDim()==3:
580                 vertex=[inf(x[0]),inf(x[1]),inf(x[2])]
581                 msk=numarray.zeros((3,))
582                 if self.comp_mask[0]: msk[0]=1
583                 if self.comp_mask[1]: msk[1]=1
584                 if self.comp_mask[2]: msk[2]=1
585              else:
586                 vertex=[inf(x[0]),inf(x[1])]
587                 msk=numarray.zeros((2,))
588                 if self.comp_mask[0]: msk[0]=1
589                 if self.comp_mask[1]: msk[1]=1
590              self.__location_of_constraint=whereZero(length(x-vertex),self.tol)*numarray.ones(shape)
591              if not self.value == None:
592                    self.__value_of_constraint=self.__location_of_constraint*self.value
593    
 # vim: expandtab shiftwidth=4:  

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

  ViewVC Help
Powered by ViewVC 1.1.26