/[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 950 by gross, Tue Feb 6 07:01:11 2007 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 30  class FinleyReader(ParameterSet): Line 45  class FinleyReader(ParameterSet):
45            """            """
46            super(FinleyReader,self).__init__(**kwargs)            super(FinleyReader,self).__init__(**kwargs)
47            self.declareParameter(source="none",            self.declareParameter(source="none",
48                                    dim=None,
49                                  optimizeLabeling=True,                                  optimizeLabeling=True,
50                                  reducedIntegrationOrder=-1,                                  reducedIntegrationOrder=-1,
51                                  integrationOrder=-1)                                  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 46  class FinleyReader(ParameterSet): Line 63  class FinleyReader(ParameterSet):
63               if  self.source.fileformat == "fly":               if  self.source.fileformat == "fly":
64                  self.__domain=finley.ReadMesh(self.source.getLocalFileName(),self.integrationOrder)                  self.__domain=finley.ReadMesh(self.source.getLocalFileName(),self.integrationOrder)
65               elif self.source.fileformat == "gmsh":               elif self.source.fileformat == "gmsh":
66                  self.__domain=finley.ReadGmsh(self.source.getLocalFileName(),self.integrationOrder,self.reducedIntegrationOrder, self.optimizeLabeling)                  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:               else:
72                  raise TypeError("unknown mesh file format %s."%self.source.fileformat)                  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))                         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 93  class RectangularDomain(ParameterSet): Line 112  class RectangularDomain(ParameterSet):
112             if self.__domain==None:             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 162  class UpdateGeometry(Model): Line 181  class UpdateGeometry(Model):
181           """           """
182           self.__reset=False           self.__reset=False
183    
184    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):  class ScalarConstrainerOverBox(Model):
267        """        """
268        Creates a characteristic function for the location of constraints        Creates a characteristic function for the location of constraints
# Line 230  class ScalarConstrainerOverBox(Model): Line 331  class ScalarConstrainerOverBox(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 VectorConstrainerOverBox(Model):  class VectorConstrainerOverBox(Model):
# Line 258  class VectorConstrainerOverBox(Model): Line 359  class VectorConstrainerOverBox(Model):
359             super(VectorConstrainerOverBox, self).__init__(**kwargs)             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 318  class VectorConstrainerOverBox(Model): Line 419  class VectorConstrainerOverBox(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 334  class VectorConstrainerOverBox(Model): Line 435  class VectorConstrainerOverBox(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.950  
changed lines
  Added in v.1387

  ViewVC Help
Powered by ViewVC 1.1.26