/[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

trunk/modellib/py_src/geometry.py revision 885 by gross, Wed Nov 1 09:05:51 2006 UTC temp/modellib/py_src/geometry.py revision 1387 by trankine, Fri Jan 11 07:45:26 2008 UTC
# Line 1  Line 1 
1    #
2  # $Id$  # $Id$
3    #
4    #######################################################
5    #
6    #           Copyright 2003-2007 by ACceSS MNRF
7    #       Copyright 2007 by University of Queensland
8    #
9    #                http://esscc.uq.edu.au
10    #        Primary Business: Queensland, Australia
11    #  Licensed under the Open Software License version 3.0
12    #     http://www.opensource.org/licenses/osl-3.0.php
13    #
14    #######################################################
15    #
16    
17    
18  __copyright__="""  Copyright (c) 2006 by ACcESS MNRF  __copyright__="""  Copyright (c) 2006 by ACcESS MNRF
19                      http://www.access.edu.au                      http://www.access.edu.au
# Line 15  class FinleyReader(ParameterSet): Line 30  class FinleyReader(ParameterSet):
30         """         """
31         reads finley mesh file.         reads finley mesh file.
32    
33         @ivar source: file name of the finley input file         @ivar source: mesh file in finley or gmsh format
34         @type source: C{str}         @type source: C{DataSource}
35         @ivar intergrationOrder: integration order, default -1 (in).         @ivar intergrationOrder: integration order, default -1 (in).
36         @type intergrationOrder: C{int}         @type intergrationOrder: C{int}
37           @ivar reducedIntegrationOrder: reduced integration order, default -1 (in).
38           @type reducedIntegrationOrder: C{int}
39           @ivar optimizeLabeling: switches on optimization of the labeling of the nodes
40           @type optimizeLabeling: C{bool}
41         """         """
42         def __init__(self,debug=False):         def __init__(self,**kwargs):
43            """            """
44            initializes the object            initializes the object
45            """            """
46            super(FinleyReader,self).__init__(debug=debug)            super(FinleyReader,self).__init__(**kwargs)
47            self.declareParameter(source="none",            self.declareParameter(source="none",
48                                   integrationOrder=-1)                                  dim=None,
49                                    optimizeLabeling=True,
50                                    reducedIntegrationOrder=-1,
51                                    integrationOrder=-1)
52            self.__domain=None            self.__domain=None
53    
54    
55         def domain(self):         def domain(self):
56            """            """
57            returns the domain            returns the domain
# Line 36  class FinleyReader(ParameterSet): Line 59  class FinleyReader(ParameterSet):
59            @return: the domain            @return: the domain
60            @rtype: L{Domain}            @rtype: L{Domain}
61            """            """
62            if not self.__domain:            if self.__domain == None:
63               self.__domain=finley.ReadMesh(self.source.getLocalFileName(),self.integrationOrder)               if  self.source.fileformat == "fly":
64               self.trace("mesh read from %s"%self.source)                            self.__domain=finley.ReadMesh(self.source.getLocalFileName(),self.integrationOrder)
65                 elif self.source.fileformat == "gmsh":
66                    if self.dim==None:
67                       dim=3
68                    else:
69                       dim=self.dim
70                    self.__domain=finley.ReadGmsh(self.source.getLocalFileName(),dim,self.integrationOrder,self.reducedIntegrationOrder, self.optimizeLabeling)
71                 else:
72                    raise TypeError("unknown mesh file format %s."%self.source.fileformat)
73                 self.trace("mesh read from %s in %s format."%(self.source.getLocalFileName(), self.source.fileformat))          
74            return self.__domain            return self.__domain
             
                         
75  class RectangularDomain(ParameterSet):  class RectangularDomain(ParameterSet):
76         """         """
77         Generates a mesh over a rectangular domain finley.         Generates a mesh over a rectangular domain finley.
# Line 59  class RectangularDomain(ParameterSet): Line 89  class RectangularDomain(ParameterSet):
89         @ivar intergrationOrder: integration order, default -1 (in).         @ivar intergrationOrder: integration order, default -1 (in).
90         @type intergrationOrder: C{int}         @type intergrationOrder: C{int}
91         """         """
92         def __init__(self,debug=False):         def __init__(self,**kwargs):
93             """             """
94             initializes the object             initializes the object
95             """             """
96             super(RectangularDomain,self).__init__(debug=debug)             super(RectangularDomain,self).__init__(**kwargs)
97             self.declareParameter(dim=2,\             self.declareParameter(dim=2,\
98                                   l=[1.,1.,1.],\                                   l=[1.,1.,1.],\
99                                   n=[10,10,10], \                                   n=[10,10,10], \
# Line 79  class RectangularDomain(ParameterSet): Line 109  class RectangularDomain(ParameterSet):
109             @return: the domain             @return: the domain
110             @rtype: L{Domain}             @rtype: L{Domain}
111             """             """
112             if not self.__domain:             if self.__domain==None:
113                if self.dim==2:                if self.dim==2:
114                     self.domain=finley.Rectangle(n0=self.n[0],\                     self.__domain=finley.Rectangle(n0=self.n[0],\
115                                                  n1=self.n[1],\                                                  n1=self.n[2],\
116                                                  l0=self.l[0],\                                                  l0=self.l[0],\
117                                                  l1=self.l[1],\                                                  l1=self.l[2],\
118                                                  order=self.order, \                                                  order=self.order, \
119                                                  periodic0=self.periodic[0], \                                                  periodic0=self.periodic[0], \
120                                                  periodic1=self.periodic[1], \                                                  periodic1=self.periodic[2], \
121                                                  integrationOrder=self.integrationOrder)                                                  integrationOrder=self.integrationOrder)
122                else:                else:
123                     self.__domain=finley.Brick(n0=self.n[0],\                     self.__domain=finley.Brick(n0=self.n[0],\
# Line 112  class UpdateGeometry(Model): Line 142  class UpdateGeometry(Model):
142        @ivar domain: domain        @ivar domain: domain
143        @type domain: L{escript.Domain}        @type domain: L{escript.Domain}
144        """        """
145        def __init__(self,debug=False):        def __init__(self,**kwargs):
146             """             """
147             set-up the object             set-up the object
148             """             """
149             super(UpdateGeometry, self).__init__(debug=debug)             super(UpdateGeometry, self).__init__(**kwargs)
150             self.declareParameter(domain=None,\             self.declareParameter(domain=None,\
151                                   displacement=None)                                   displacement=None)
152    
# Line 151  class UpdateGeometry(Model): Line 181  class UpdateGeometry(Model):
181           """           """
182           self.__reset=False           self.__reset=False
183    
184  class ScalarConstrainer(Model):  class ConstrainerOverBox(Model):
185          """
186          Creates a characteristic function for the location of constraints
187          for all components of a value and selects the value from an initial value
188          ate these locations.
189    
190          In the case that the spatial dimension is two, the arguments front and back are ignored.
191    
192          @ivar domain: domain (in).
193          @ivar left:  True to set a constraint at the left face of the domain (x[0]=min x[0]), default False (in).
194          @ivar right: True to set a constraint at the left face of the domain (x[0]=max x[0]), default False (in).
195          @ivar top: True to set a constraint at the left face of the domain (x[1]=min x[1]), default False (in).
196          @ivar bottom: True to set a constraint at the left face of the domain (x[1]=max x[1]), default False (in).
197          @ivar front: True to set a constraint at the left face of the domain (x[2]=min x[2]), default False (in).
198          @ivar back: True to set a constraint at the left face of the domain (x[2]=max x[2]), default False (in).
199          @ivar tol: absolute tolerance for "x=max x" condition, default 1.e-8 (in).
200          """
201          def __init__(self,**kwargs):
202               super(ConstrainerOverBox, self).__init__(**kwargs)
203               self.declareParameter(domain=None, \
204                                     value=None,  \
205                                     left=False, \
206                                     right=False, \
207                                     top=False, \
208                                     bottom=False, \
209                                     front=False, \
210                                     back=False, \
211                                     tol=1.e-8)
212               self.__value_of_constraint = None
213               self.__location_of_constraint=None
214          def location_of_constraint(self):
215              """
216              return the values used to constrain a solution
217    
218              @return: the mask marking the locations of the constraints
219              @rtype: L{escript.Scalar}
220              """
221              if self.__location_of_constraint == None: self.__setOutput()
222              return self.__location_of_constraint
223            
224          def value_of_constraint(self):
225              """
226              return the values used to constrain a solution
227    
228              @return: values to be used at the locations of the constraints. If
229                      L{value} is not given C{None} is rerturned.
230              @rtype: L{escript.Scalar}
231              """
232              if self.__location_of_constraint == None: self.__setOutput()
233              return self.__value_of_constraint
234            
235          def __setOutput(self):
236              if self.__location_of_constraint == None:
237                 x=self.domain.getX()
238                 val=self.value
239                 if isinstance(val, int) or isinstance(val, float):
240                    shape=()
241                 elif isinstance(val, list) or isinstance(val, tuple) :
242                    shape=(len(val),)
243                 elif isinstance(val, numarray.NumArray):
244                     shape=val.shape
245                 elif val == None:
246                      shape=()
247                 else:
248                     shape=val.getShape()
249                 self.__location_of_constraint=Data(0,shape,x.getFunctionSpace())
250                 if self.domain.getDim()==3:
251                       x0,x1,x2=x[0],x[1],x[2]
252                       if self.left: self.__location_of_constraint+=whereZero(x0-inf(x0),self.tol)
253                       if self.right: self.__location_of_constraint+=whereZero(x0-sup(x0),self.tol)
254                       if self.front: self.__location_of_constraint+=whereZero(x1-inf(x1),self.tol)
255                       if self.back: self.__location_of_constraint+=whereZero(x1-sup(x1),self.tol)
256                       if self.bottom: self.__location_of_constraint+=whereZero(x2-inf(x2),self.tol)
257                       if self.top: self.__location_of_constraint+=whereZero(x2-sup(x2),self.tol)
258                 else:
259                       x0,x1=x[0],x[1]
260                       if self.left: self.__location_of_constraint+=whereZero(x0-inf(x0),self.tol)
261                       if self.right: self.__location_of_constraint+=whereZero(x0-sup(x0),self.tol)
262                       if self.bottom: self.__location_of_constraint+=whereZero(x1-inf(x1),self.tol)
263                       if self.top: self.__location_of_constraint+=whereZero(x1-sup(x1),self.tol)
264                 if not self.value == None:
265                       self.__value_of_constraint=self.__location_of_constraint*self.value
266    class ScalarConstrainerOverBox(Model):
267        """        """
268        Creates a characteristic function for the location of constraints        Creates a characteristic function for the location of constraints
269        for a scalar value and selects the value from an initial value        for a scalar value and selects the value from an initial value
# Line 168  class ScalarConstrainer(Model): Line 280  class ScalarConstrainer(Model):
280        @ivar back: True to set a constraint at the left face of the domain (x[2]=max x[2]), default False (in).        @ivar back: True to set a constraint at the left face of the domain (x[2]=max x[2]), default False (in).
281        @ivar tol: absolute tolerance for "x=max x" condition, default 1.e-8 (in).        @ivar tol: absolute tolerance for "x=max x" condition, default 1.e-8 (in).
282        """        """
283        def __init__(self,debug=False):        def __init__(self,**kwargs):
284             ParameterSet.__init__(self,debug=debug)             super(ScalarConstrainerOverBox, self).__init__(**kwargs)
285             self.declareParameter(domain=None, \             self.declareParameter(domain=None, \
286                                   value=None,  \                                   value=None,  \
287                                   left=False, \                                   left=False, \
# Line 188  class ScalarConstrainer(Model): Line 300  class ScalarConstrainer(Model):
300            @return: the mask marking the locations of the constraints            @return: the mask marking the locations of the constraints
301            @rtype: L{escript.Scalar}            @rtype: L{escript.Scalar}
302            """            """
303            if not self.__location_of_constraint: self.__setOutput()            if self.__location_of_constraint == None: self.__setOutput()
304            return self.__location_of_constraint            return self.__location_of_constraint
305                    
306        def value_of_constraint(self):        def value_of_constraint(self):
# Line 199  class ScalarConstrainer(Model): Line 311  class ScalarConstrainer(Model):
311                    L{value} is not given C{None} is rerturned.                    L{value} is not given C{None} is rerturned.
312            @rtype: L{escript.Scalar}            @rtype: L{escript.Scalar}
313            """            """
314            if not self.__location_of_constraint: self.__setOutput()            if self.__location_of_constraint == None: self.__setOutput()
315            return self.__value_of_constraint            return self.__value_of_constraint
316                    
317        def __setOutput(self):        def __setOutput(self):
# Line 219  class ScalarConstrainer(Model): Line 331  class ScalarConstrainer(Model):
331                  if self.right: self.__location_of_constraint+=whereZero(x0-sup(x0),self.tol)                  if self.right: self.__location_of_constraint+=whereZero(x0-sup(x0),self.tol)
332                  if self.bottom: self.__location_of_constraint+=whereZero(x1-inf(x1),self.tol)                  if self.bottom: self.__location_of_constraint+=whereZero(x1-inf(x1),self.tol)
333                  if self.top: self.__location_of_constraint+=whereZero(x1-sup(x1),self.tol)                  if self.top: self.__location_of_constraint+=whereZero(x1-sup(x1),self.tol)
334            if self.value:            if not self.value == None:
335                self.__value_of_constraint=self.__location_of_constraint*self.value                self.__value_of_constraint=self.__location_of_constraint*self.value
336    
337  class VectorConstrainer(Model):  class VectorConstrainerOverBox(Model):
338        """        """
339        Creates a characteristic function for the location of constraints vector value.        Creates a characteristic function for the location of constraints vector value.
340        In the case that the spatial dimension is two, the arguments front and        In the case that the spatial dimension is two, the arguments front and
# Line 243  class VectorConstrainer(Model): Line 355  class VectorConstrainer(Model):
355                  default [False,False,False] (in).                  default [False,False,False] (in).
356        @ivar tol: absolute tolerance for "x=max x" condition, default 1.e-8 (in).        @ivar tol: absolute tolerance for "x=max x" condition, default 1.e-8 (in).
357        """        """
358        def __init__(self,debug=False):        def __init__(self, **kwargs):
359             ParameterSet.__init__(self,debug=debug)             super(VectorConstrainerOverBox, self).__init__(**kwargs)
360             self.declareParameter(domain=None, \             self.declareParameter(domain=None, \
361                                   value=None,  \                                   value=None,  \
362                                   left=[0,0,0],  \                                   left=[False ,False ,False ],  \
363                                   right=[0,0,0],  \                                   right=[False ,False ,False ],  \
364                                   top=[0,0,0],  \                                   top=[False ,False ,False ],  \
365                                   bottom=[0,0,0],  \                                   bottom=[False ,False ,False ],  \
366                                   front=[0,0,0], \                                   front=[False ,False ,False ], \
367                                   back=[0,0,0], \                                   back=[False ,False ,False ], \
368                                   tol=1.e-8)                                   tol=1.e-8)
369             self.__value_of_constraint = None             self.__value_of_constraint = None
370             self.__location_of_constraint=None             self.__location_of_constraint=None
# Line 264  class VectorConstrainer(Model): Line 376  class VectorConstrainer(Model):
376            @return: the mask marking the locations of the constraints            @return: the mask marking the locations of the constraints
377            @rtype: L{escript.Vector}            @rtype: L{escript.Vector}
378            """            """
379            if not self.__location_of_constraint: self.__setOutput()            if self.__location_of_constraint == None: self.__setOutput()
380            return self.__location_of_constraint            return self.__location_of_constraint
381                    
382        def value_of_constraint(self):        def value_of_constraint(self):
# Line 275  class VectorConstrainer(Model): Line 387  class VectorConstrainer(Model):
387                    L{value} is not given C{None} is rerturned.                    L{value} is not given C{None} is rerturned.
388            @rtype: L{escript.Vector}            @rtype: L{escript.Vector}
389            """            """
390            if not self.__location_of_constraint: self.__setOutput()            if self.__location_of_constraint == None: self.__setOutput()
391            return self.__value_of_constraint            return self.__value_of_constraint
392                    
393        def __setOutput(self):        def __setOutput(self):
# Line 307  class VectorConstrainer(Model): Line 419  class VectorConstrainer(Model):
419               if self.top[0]: self.__location_of_constraint+=top_mask*[1.,0.,0.]               if self.top[0]: self.__location_of_constraint+=top_mask*[1.,0.,0.]
420               if self.top[1]: self.__location_of_constraint+=top_mask*[0.,1.,0.]               if self.top[1]: self.__location_of_constraint+=top_mask*[0.,1.,0.]
421               if self.top[2]: self.__location_of_constraint+=top_mask*[0.,0.,1.]               if self.top[2]: self.__location_of_constraint+=top_mask*[0.,0.,1.]
422               if self.value:               if not self.value == None:
423                  self.__value_of_constraint=self.__location_of_constraint*self.value                  self.__value_of_constraint=self.__location_of_constraint*self.value
424            else:            else:
425               x0,x1=x[0],x[1]               x0,x1=x[0],x[1]
# Line 323  class VectorConstrainer(Model): Line 435  class VectorConstrainer(Model):
435               top_mask=whereZero(x1-sup(x1),self.tol)               top_mask=whereZero(x1-sup(x1),self.tol)
436               if self.top[0]: self.__location_of_constraint+=top_mask*[1.,0.]               if self.top[0]: self.__location_of_constraint+=top_mask*[1.,0.]
437               if self.top[1]: self.__location_of_constraint+=top_mask*[0.,1.]               if self.top[1]: self.__location_of_constraint+=top_mask*[0.,1.]
438               if self.value:               if not self.value == None:
439                  self.__value_of_constraint=self.__location_of_constraint*self.value[:2]                  self.__value_of_constraint=self.__location_of_constraint*self.value[:2]
440    
441  # vim: expandtab shiftwidth=4:  class ConstrainerAtBoxVertex(Model):
442          """
443          Creates a characteristic function for the location of constraints
444          for all components of a value and selects the value from an initial value
445          ate these locations.
446    
447          In the case that the spatial dimension is two, the arguments front and back are ignored.
448    
449          @ivar domain: domain (in).
450          @ivar tol: absolute tolerance for "x=left, front, bottom vertex" condition, default 1.e-8 (in).
451          """
452          def __init__(self,**kwargs):
453               super(ConstrainerAtBoxVertex, self).__init__(**kwargs)
454               self.declareParameter(domain=None, \
455                                     value=None,  \
456                                     tol=1.e-8)
457               self.__value_of_constraint = None
458               self.__location_of_constraint=None
459          def location_of_constraint(self):
460              """
461              return the values used to constrain a solution
462    
463              @return: the mask marking the locations of the constraints
464              @rtype: L{escript.Scalar}
465              """
466              if self.__location_of_constraint == None: self.__setOutput()
467              return self.__location_of_constraint
468            
469          def value_of_constraint(self):
470              """
471              return the values used to constrain a solution
472    
473              @return: values to be used at the locations of the constraints. If
474                      L{value} is not given C{None} is rerturned.
475              @rtype: L{escript.Scalar}
476              """
477              if self.__location_of_constraint == None: self.__setOutput()
478              return self.__value_of_constraint
479            
480          def __setOutput(self):
481              if self.__location_of_constraint == None:
482                 x=self.domain.getX()
483                 val=self.value
484                 if isinstance(val, int) or isinstance(val, float):
485                    shape=()
486                 elif isinstance(val, list) or isinstance(val, tuple) :
487                    shape=(len(val),)
488                 elif isinstance(val, numarray.NumArray):
489                     shape=val.shape
490                 elif val == None:
491                      shape=()
492                 else:
493                     shape=val.getShape()
494                 if self.domain.getDim()==3:
495                       vertex=[inf(x[0]),inf(x[1]),inf(x[2])]
496                 else:
497                       vertex=[inf(x[0]),inf(x[1])]
498                 self.__location_of_constraint=whereZero(length(x-vertex),self.tol)*numarray.ones(shape)
499                 if not self.value == None:
500                       self.__value_of_constraint=self.__location_of_constraint*self.value
501    class ScalarConstrainerAtBoxVertex(Model):
502          """
503          Creates a characteristic function for the location of constraints
504          for a scalar value and selects the value from an initial value
505          ate these locations.
506    
507          In the case that the spatial dimension is two, the arguments front and back are ignored.
508    
509          @ivar domain: domain (in).
510          @ivar tol: absolute tolerance for "x=left, front, bottom vertex" condition, default 1.e-8 (in).
511          """
512          def __init__(self,**kwargs):
513               super(ScalarConstrainerAtBoxVertex, self).__init__(**kwargs)
514               self.declareParameter(domain=None, \
515                                     value=None,  \
516                                     tol=1.e-8)
517               self.__value_of_constraint = None
518               self.__location_of_constraint=None
519          def location_of_constraint(self):
520              """
521              return the values used to constrain a solution
522    
523              @return: the mask marking the locations of the constraints
524              @rtype: L{escript.Scalar}
525              """
526              if self.__location_of_constraint == None: self.__setOutput()
527              return self.__location_of_constraint
528            
529          def value_of_constraint(self):
530              """
531              return the values used to constrain a solution
532    
533              @return: values to be used at the locations of the constraints. If
534                      L{value} is not given C{None} is rerturned.
535              @rtype: L{escript.Scalar}
536              """
537              if self.__location_of_constraint == None: self.__setOutput()
538              return self.__value_of_constraint
539            
540          def __setOutput(self):
541              x=self.domain.getX()
542              self.__location_of_constraint=Scalar(0,x.getFunctionSpace())
543              if self.domain.getDim()==3:
544                       vertex=[inf(x[0]),inf(x[1]),inf(x[2])]
545              else:
546                     vertex=[inf(x[0]),inf(x[1])]
547              self.__location_of_constraint=whereZero(length(x-vertex),self.tol)
548              if not self.value == None:
549                  self.__value_of_constraint=self.__location_of_constraint*self.value
550    
551    class VectorConstrainerAtBoxVertex(Model):
552          """
553          Creates a characteristic function for the location of constraints vector value.
554          In the case that the spatial dimension is two, the arguments front and
555          back as well as the third component of each argument is ignored.
556    
557          @ivar domain: domain
558          @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).
559          @ivar tol: absolute tolerance for "x=left, front, bottom vertex" condition, default 1.e-8 (in).
560          """
561          def __init__(self, **kwargs):
562               super(VectorConstrainerAtBoxVertex, self).__init__(**kwargs)
563               self.declareParameter(domain=None, \
564                                     value=None,  \
565                                     comp_mask=[False, False, False],
566                                     tol=1.e-8)
567               self.__value_of_constraint = None
568               self.__location_of_constraint=None
569    
570          def location_of_constraint(self):
571              """
572              return the values used to constrain a solution
573    
574              @return: the mask marking the locations of the constraints
575              @rtype: L{escript.Vector}
576              """
577              if self.__location_of_constraint == None: self.__setOutput()
578              return self.__location_of_constraint
579            
580          def value_of_constraint(self):
581              """
582              return the values used to constrain a solution
583    
584              @return: values to be used at the locations of the constraints. If
585                      L{value} is not given C{None} is rerturned.
586              @rtype: L{escript.Vector}
587              """
588              if self.__location_of_constraint == None: self.__setOutput()
589              return self.__value_of_constraint
590            
591          def __setOutput(self):
592              x=self.domain.getX()
593              self.__location_of_constraint=Vector(0,x.getFunctionSpace())
594              if self.domain.getDim()==3:
595                 vertex=[inf(x[0]),inf(x[1]),inf(x[2])]
596                 msk=numarray.zeros((3,))
597                 if self.comp_mask[0]: msk[0]=1
598                 if self.comp_mask[1]: msk[1]=1
599                 if self.comp_mask[2]: msk[2]=1
600              else:
601                 vertex=[inf(x[0]),inf(x[1])]
602                 msk=numarray.zeros((2,))
603                 if self.comp_mask[0]: msk[0]=1
604                 if self.comp_mask[1]: msk[1]=1
605              self.__location_of_constraint=whereZero(length(x-vertex),self.tol)*numarray.ones(shape)
606              if not self.value == None:
607                    self.__value_of_constraint=self.__location_of_constraint*self.value
608    

Legend:
Removed from v.885  
changed lines
  Added in v.1387

  ViewVC Help
Powered by ViewVC 1.1.26