/[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 1044 by gross, Mon Mar 19 07:29:31 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 9  __license__="""Licensed under the Open S Line 24  __license__="""Licensed under the Open S
24    
25  from esys.escript import *  from esys.escript import *
26  from esys.escript.modelframe import Model,ParameterSet  from esys.escript.modelframe import Model,ParameterSet
 from esys.pycad import TagMap  
27  from esys import finley  from esys import finley
28    
29  class FinleyReader(ParameterSet):  class FinleyReader(ParameterSet):
# Line 32  class FinleyReader(ParameterSet): Line 46  class FinleyReader(ParameterSet):
46            super(FinleyReader,self).__init__(**kwargs)            super(FinleyReader,self).__init__(**kwargs)
47            self.declareParameter(source="none",            self.declareParameter(source="none",
48                                  dim=None,                                  dim=None,
                                 tag_map_source=None,  
49                                  optimizeLabeling=True,                                  optimizeLabeling=True,
50                                  reducedIntegrationOrder=-1,                                  reducedIntegrationOrder=-1,
51                                  integrationOrder=-1)                                  integrationOrder=-1)
52            self.__domain=None            self.__domain=None
           self.__tag_map=None  
53    
54    
55         def domain(self):         def domain(self):
# Line 59  class FinleyReader(ParameterSet): Line 71  class FinleyReader(ParameterSet):
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))          
              self.__tag_map = TagMap()  
              if  self.tag_map_source != None:  
                    self.__tag_map.fillFromXML(open(self.tag_map_source.getLocalFileName()))  
              self.trace("tag map read from %s in %s format."%(self.tag_map_source.getLocalFileName(), self.tag_map_source.fileformat))            
              self.__tag_map.passToDomain(self.__domain)  
74            return self.__domain            return self.__domain
   
        def tag_map(self):  
           """  
           returns the map from regional tag names to tag integers used in the mesh  
   
           @return: the tag map  
           @rtype: L{TagMap}  
           """  
           return self.__tag_map  
   
                         
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 116  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 363  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 442  class VectorConstrainerOverBox(Model): Line 438  class VectorConstrainerOverBox(Model):
438               if not self.value == None:               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.1044  
changed lines
  Added in v.1387

  ViewVC Help
Powered by ViewVC 1.1.26