modellib/py_src/geometry.py

# $Id$


from escript.escript import *
from escript.modelframe import Model
from finley import finley

class RectangularDomain(Model):
       """generates a mesh over a rectangular domain finley

             dim
             l
             n
             order
             periodic
             intergration order

             domain (callable)

       """
       def __init__(self,debug=False):
           Model.__init__(self,debug=debug)
           self.declareParameter(dim=2,\
                                 l=[1.,1.,1.],\
                                 n=[10,10,10], \
                 order=1,\
                                 periodic=[False,False,False],\
                                 integrationOrder=-1)
           self._domain=None

       def domain(self):
          if self._domain==None:
             if self.dim==2:
                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)

          return self._domain

class ScalarConstrainer(Model):
     """@brief creates a characteristic function for the location of constraints for a scalar value

              @param domain (in) - rectangular domain
              @param left (in)  - True to set a constraint at the left face of the domain (x[0]=min x[0]), default is False
              @param right (in) - True to set a constraint at the left face of the domain (x[0]=max x[0]), default is False
              @param top (in)  - True to set a constraint at the left face of the domain (x[1]=min x[1]), default is False
              @param bottom (in) - True to set a constraint at the left face of the domain (x[1]=max x[1]), default is False
              @param front (in)  - True to set a constraint at the left face of the domain (x[2]=min x[2]), default is False
              @param back (in) - True to set a constraint at the left face of the domain (x[2]=max x[2]), default is False
              @param location_of_constraint (out) - object that defines the location of the constraints.

       In the case that the spatial dimension is two, teh arguments front and back are ignored

     """
     def __init__(self,debug=False):
           Model.__init__(self,debug=debug)
           self.declareParameter(domain=None, \
                                 left=False, \
                                 right=False, \
                                 top=False, \
                                 bottom=False, \
                                 front=False, \
                                 back=False)
           self._location_of_constraint=None

     def location_of_constraint(self):
          """returns the mask of the location of constraint"""
          if self._location_of_constraint==None:
             x=self.domain.getX()
             self._location_of_constraint=Scalar(0,x.getFunctionSpace())
             if self.domain.getDim()==3:
                if self.left: self._location_of_constraint+=(x[0]-inf(x[0])).whereZero()
                if self.right: self._location_of_constraint+=(x[0]-sup(x[0])).whereZero()
                if self.front: self._location_of_constraint+=(x[1]-inf(x[1])).whereZero()
                if self.back: self._location_of_constraint+=(x[1]-sup(x[1])).whereZero()
                if self.bottom: self._location_of_constraint+=(x[2]-inf(x[2])).whereZero()
                if self.top: self._location_of_constraint+=(x[2]-sup(x[2])).whereZero()
             else:
                if self.left: self._location_of_constraint+=(x[0]-inf(x[0])).whereZero()
                if self.right: self._location_of_constraint+=(x[0]-sup(x[0])).whereZero()
                if self.bottom: self._location_of_constraint+=(x[1]-inf(x[1])).whereZero()
                if self.top: self._location_of_constraint+=(x[1]-sup(x[1])).whereZero()
          return self._location_of_constraint

class VectorConstrainer(Model):
      """@brief creates a characteristic function for the location of constraints for a scalar value

              @param domain (in) - rectangular domain
              @param left (in)  - 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]), default is [False,False,False]
              @param right (in) - 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]), default is [False,False,False]
              @param top (in)  - 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]), default is [False,False,False]
              @param bottom (in) - 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]), default is [False,False,False]
              @param front (in)  - 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]), default is [False,False,False]
              @param back (in) - 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]), default is [False,False,False]
              @param location_of_constraint (callable) - object that defines the location of the constraints for each vector component.

       In the case that the spatial dimension is two, thh arguments front and back as well as the third component of each argument is ignored.

      """
      def __init__(self,debug=False):
           Model.__init__(self,debug=debug)
           self.declareParameter(domain=None, \
                                 left=[0,0,0],  \
                                 right=[0,0,0],  \
                                 top=[0,0,0],  \
                                 bottom=[0,0,0],  \
                                 front=[0,0,0],
                                 back=[0,0,0])
           self._location_of_constraint=None
      def location_of_constraint(self):
          """returns the mask of the location of constraint"""
          if self._location_of_constraint==None:
             x=self.domain.getX()
             self._location_of_constraint=Vector(0,x.getFunctionSpace())
             if self.domain.getDim()==3:
                left_mask=(x[0]-inf(x[0])).whereZero()
                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=(x[0]-sup(x[0])).whereZero()
                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=(x[1]-inf(x[1])).whereZero()
                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=(x[1]-sup(x[1])).whereZero()
                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=(x[2]-inf(x[2])).whereZero()
                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=(x[2]-sup(x[2])).whereZero()
                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.]
             else:
                left_mask=(x[0]-inf(x[0])).whereZero()
                if self.left[0]: self._location_of_constraint+=left_mask*[1.,0.]
                if self.left[1]: self._location_of_constraint+=left_mask*[0.,1.]
                right_mask=(x[0]-sup(x[0])).whereZero()
                if self.right[0]: self._location_of_constraint+=right_mask*[1.,0.]
                if self.right[1]: self._location_of_constraint+=right_mask*[0.,1.]
                bottom_mask=(x[1]-inf(x[1])).whereZero()
                if self.bottom[0]: self._location_of_constraint+=bottom_mask*[1.,0.]
                if self.bottom[1]: self._location_of_constraint+=bottom_mask*[0.,1.]
                top_mask=(x[1]-sup(x[1])).whereZero()
                if self.top[0]: self._location_of_constraint+=top_mask*[1.,0.]
                if self.top[1]: self._location_of_constraint+=top_mask*[0.,1.]
          return self._location_of_constraint
1	jgs	127	# $Id$
2
3
4	jgs	147	from escript.escript import *
5			from escript.modelframe import Model
6			from finley import finley
7	jgs	127
8			class RectangularDomain(Model):
9	jgs	147	"""generates a mesh over a rectangular domain finley
10
11			dim
12			l
13			n
14			order
15			periodic
16			intergration order
17
18			domain (callable)
19
20			"""
21	jgs	127	def __init__(self,debug=False):
22			Model.__init__(self,debug=debug)
23	jgs	147	self.declareParameter(dim=2,\
24	jgs	127	l=[1.,1.,1.],\
25			n=[10,10,10], \
26			order=1,\
27			periodic=[False,False,False],\
28			integrationOrder=-1)
29	jgs	147	self._domain=None
30	jgs	127
31	jgs	147	def domain(self):
32			if self._domain==None:
33			if self.dim==2:
34			self._domain=finley.Rectangle(n0=self.n[0],\
35			n1=self.n[1],\
36			l0=self.l[0],\
37			l1=self.l[1],\
38			order=self.order, \
39			periodic0=self.periodic[0], \
40			periodic1=self.periodic[1], \
41			integrationOrder=self.integrationOrder)
42			else:
43			self._domain=finley.Brick(n0=self.n[0],\
44			n1=self.n[1],\
45			n2=self.n[2],\
46			l0=self.l[0],\
47			l1=self.l[1],\
48			l2=self.l[2],\
49			order=self.order, \
50			periodic0=self.periodic[0], \
51			periodic1=self.periodic[1], \
52			periodic2=self.periodic[2], \
53			integrationOrder=self.integrationOrder)
54
55			return self._domain
56
57	jgs	127	class ScalarConstrainer(Model):
58			"""@brief creates a characteristic function for the location of constraints for a scalar value
59
60			@param domain (in) - rectangular domain
61			@param left (in) - True to set a constraint at the left face of the domain (x[0]=min x[0]), default is False
62			@param right (in) - True to set a constraint at the left face of the domain (x[0]=max x[0]), default is False
63			@param top (in) - True to set a constraint at the left face of the domain (x[1]=min x[1]), default is False
64			@param bottom (in) - True to set a constraint at the left face of the domain (x[1]=max x[1]), default is False
65			@param front (in) - True to set a constraint at the left face of the domain (x[2]=min x[2]), default is False
66			@param back (in) - True to set a constraint at the left face of the domain (x[2]=max x[2]), default is False
67			@param location_of_constraint (out) - object that defines the location of the constraints.
68
69			In the case that the spatial dimension is two, teh arguments front and back are ignored
70
71			"""
72			def __init__(self,debug=False):
73			Model.__init__(self,debug=debug)
74			self.declareParameter(domain=None, \
75	jgs	147	left=False, \
76			right=False, \
77			top=False, \
78			bottom=False, \
79			front=False, \
80			back=False)
81			self._location_of_constraint=None
82	jgs	127
83	jgs	147	def location_of_constraint(self):
84			"""returns the mask of the location of constraint"""
85			if self._location_of_constraint==None:
86			x=self.domain.getX()
87			self._location_of_constraint=Scalar(0,x.getFunctionSpace())
88			if self.domain.getDim()==3:
89			if self.left: self._location_of_constraint+=(x[0]-inf(x[0])).whereZero()
90			if self.right: self._location_of_constraint+=(x[0]-sup(x[0])).whereZero()
91			if self.front: self._location_of_constraint+=(x[1]-inf(x[1])).whereZero()
92			if self.back: self._location_of_constraint+=(x[1]-sup(x[1])).whereZero()
93			if self.bottom: self._location_of_constraint+=(x[2]-inf(x[2])).whereZero()
94			if self.top: self._location_of_constraint+=(x[2]-sup(x[2])).whereZero()
95			else:
96			if self.left: self._location_of_constraint+=(x[0]-inf(x[0])).whereZero()
97			if self.right: self._location_of_constraint+=(x[0]-sup(x[0])).whereZero()
98			if self.bottom: self._location_of_constraint+=(x[1]-inf(x[1])).whereZero()
99			if self.top: self._location_of_constraint+=(x[1]-sup(x[1])).whereZero()
100			return self._location_of_constraint
101
102	jgs	127	class VectorConstrainer(Model):
103			"""@brief creates a characteristic function for the location of constraints for a scalar value
104
105			@param domain (in) - rectangular domain
106			@param left (in) - list of three boolean. left[i]==True sets a constraint for the i-th component at the left
107			face of the domain (x[0]=min x[0]), default is [False,False,False]
108			@param right (in) - list of three boolean. left[i]==True sets a constraint for the i-th component at the right
109			face of the domain (x[0]=max x[0]), default is [False,False,False]
110			@param top (in) - list of three boolean. left[i]==True sets a constraint for the i-th component at the top
111			face of the domain (x[1]=min x[1]), default is [False,False,False]
112			@param bottom (in) - list of three boolean. left[i]==True sets a constraint for the i-th component at the bottom
113			face of the domain (x[1]=min x[1]), default is [False,False,False]
114			@param front (in) - list of three boolean. left[i]==True sets a constraint for the i-th component at the front
115			face of the domain (x[2]=min x[2]), default is [False,False,False]
116			@param back (in) - list of three boolean. left[i]==True sets a constraint for the i-th component at the back
117			face of the domain (x[2]=max x[2]), default is [False,False,False]
118	jgs	147	@param location_of_constraint (callable) - object that defines the location of the constraints for each vector component.
119	jgs	127
120			In the case that the spatial dimension is two, thh arguments front and back as well as the third component of each argument is ignored.
121
122			"""
123			def __init__(self,debug=False):
124			Model.__init__(self,debug=debug)
125			self.declareParameter(domain=None, \
126	jgs	147	left=[0,0,0], \
127			right=[0,0,0], \
128			top=[0,0,0], \
129			bottom=[0,0,0], \
130	jgs	127	front=[0,0,0],
131	jgs	147	back=[0,0,0])
132			self._location_of_constraint=None
133			def location_of_constraint(self):
134			"""returns the mask of the location of constraint"""
135			if self._location_of_constraint==None:
136			x=self.domain.getX()
137			self._location_of_constraint=Vector(0,x.getFunctionSpace())
138			if self.domain.getDim()==3:
139			left_mask=(x[0]-inf(x[0])).whereZero()
140			if self.left[0]: self._location_of_constraint+=left_mask*[1.,0.,0.]
141			if self.left[1]: self._location_of_constraint+=left_mask*[0.,1.,0.]
142			if self.left[2]: self._location_of_constraint+=left_mask*[0.,0.,1.]
143			right_mask=(x[0]-sup(x[0])).whereZero()
144			if self.right[0]: self._location_of_constraint+=right_mask*[1.,0.,0.]
145			if self.right[1]: self._location_of_constraint+=right_mask*[0.,1.,0.]
146			if self.right[2]: self._location_of_constraint+=right_mask*[0.,0.,1.]
147			front_mask=(x[1]-inf(x[1])).whereZero()
148			if self.front[0]: self._location_of_constraint+=front_mask*[1.,0.,0.]
149			if self.front[1]: self._location_of_constraint+=front_mask*[0.,1.,0.]
150			if self.front[2]: self._location_of_constraint+=front_mask*[0.,0.,1.]
151			back_mask=(x[1]-sup(x[1])).whereZero()
152			if self.back[0]: self._location_of_constraint+=back_mask*[1.,0.,0.]
153			if self.back[1]: self._location_of_constraint+=back_mask*[0.,1.,0.]
154			if self.back[2]: self._location_of_constraint+=back_mask*[0.,0.,1.]
155			bottom_mask=(x[2]-inf(x[2])).whereZero()
156			if self.bottom[0]: self._location_of_constraint+=bottom_mask*[1.,0.,0.]
157			if self.bottom[1]: self._location_of_constraint+=bottom_mask*[0.,1.,0.]
158			if self.bottom[2]: self._location_of_constraint+=bottom_mask*[0.,0.,1.]
159			top_mask=(x[2]-sup(x[2])).whereZero()
160			if self.top[0]: self._location_of_constraint+=top_mask*[1.,0.,0.]
161			if self.top[1]: self._location_of_constraint+=top_mask*[0.,1.,0.]
162			if self.top[2]: self._location_of_constraint+=top_mask*[0.,0.,1.]
163			else:
164			left_mask=(x[0]-inf(x[0])).whereZero()
165			if self.left[0]: self._location_of_constraint+=left_mask*[1.,0.]
166			if self.left[1]: self._location_of_constraint+=left_mask*[0.,1.]
167			right_mask=(x[0]-sup(x[0])).whereZero()
168			if self.right[0]: self._location_of_constraint+=right_mask*[1.,0.]
169			if self.right[1]: self._location_of_constraint+=right_mask*[0.,1.]
170			bottom_mask=(x[1]-inf(x[1])).whereZero()
171			if self.bottom[0]: self._location_of_constraint+=bottom_mask*[1.,0.]
172			if self.bottom[1]: self._location_of_constraint+=bottom_mask*[0.,1.]
173			top_mask=(x[1]-sup(x[1])).whereZero()
174			if self.top[0]: self._location_of_constraint+=top_mask*[1.,0.]
175			if self.top[1]: self._location_of_constraint+=top_mask*[0.,1.]
176			return self._location_of_constraint
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision