/[escript]/branches/3.4.1/modellib/py_src/input.py
ViewVC logotype

Diff of /branches/3.4.1/modellib/py_src/input.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/esys2/modellib/py_src/input.py revision 149 by jgs, Thu Sep 1 03:31:39 2005 UTC trunk/modellib/py_src/input.py revision 2625 by jfenwick, Fri Aug 21 06:30:25 2009 UTC
# Line 1  Line 1 
1  # $Id$  
2    ########################################################
3    #
4    # Copyright (c) 2003-2009 by University of Queensland
5    # Earth Systems Science Computational Center (ESSCC)
6    # http://www.uq.edu.au/esscc
7    #
8    # Primary Business: Queensland, Australia
9    # Licensed under the Open Software License version 3.0
10    # http://www.opensource.org/licenses/osl-3.0.php
11    #
12    ########################################################
13    
14    __copyright__="""Copyright (c) 2003-2009 by University of Queensland
15    Earth Systems Science Computational Center (ESSCC)
16    http://www.uq.edu.au/esscc
17    Primary Business: Queensland, Australia"""
18    __license__="""Licensed under the Open Software License version 3.0
19    http://www.opensource.org/licenses/osl-3.0.php"""
20    __url__="https://launchpad.net/escript-finley"
21    
22  from esys.escript import *  from esys.escript import *
23  from esys.escript.modelframe import Model,ParameterSet  from esys.escript.modelframe import Model,ParameterSet
24    from esys.escript.linearPDEs import LinearPDE
25  from math import log  from math import log
26    
27  class Sequencer(Model):  class Sequencer(Model):
28      """      """
29      Runs through time until t_end is reached.      Runs through time until t_end is reached.
30    
31        :ivar t_end: model is terminated when t_end is passed, default 1 (in).
32        :type t_end: ``float``
33        :ivar dt_max: maximum time step size, default `Model.UNDEF_DT` (in)
34        :type dt_max: ``float``
35        :ivar t: current time stamp (in/out). By default it is initialized with zero.
36        :type t: ``float``
37    
38      """      """
39      def __init__(self,t=0.,t_end=Model.UNDEF_DT,dt_max=Model.UNDEF_DT,debug=False):      def __init__(self,**kwargs):
40          """          """
41          @param t_end: - model is terminated when t_end is passed            """
42                     (exposed in writeXML)          super(Sequencer,self).__init__(**kwargs)
43          @type t_end: float          self.declareParameter(t=0.,
44          @param dt_max: - maximum time step size                                t_end=1.,
45          @type dt_max: float                                dt_max=Model.UNDEF_DT)
         @param t: - initial time  
         @type t: float  
   
         """  
         Model.__init__(self,debug=debug)  
         self.declareParameter(t=t, \  
                               t_end=t_end,  \  
                               dt_max=dt_max)  
46    
47      def doInitialization(self):      def doInitialization(self):
48          """          """
# Line 37  class Sequencer(Model): Line 58  class Sequencer(Model):
58    
59      def finalize(self):      def finalize(self):
60          """          """
61          true when t has reached t_end          returns true when `t` has reached `t_end`
62          """          """
63          return self.t >= self.t_end          return self.t >= self.t_end
64    
65      def getSafeTimeStepSize(self, dt):      def getSafeTimeStepSize(self, dt):
66          """          """
67          returns dt_max          returns `dt_max`
68          """          """
69          return self.dt_max          return self.dt_max
70    
# Line 52  class GaussianProfile(ParameterSet): Line 73  class GaussianProfile(ParameterSet):
73      Generates a Gaussian profile at center x_c, width width and height A      Generates a Gaussian profile at center x_c, width width and height A
74      over a domain      over a domain
75    
76      @ivar domain (in): domain      :ivar domain: domain
77      @ivar x_c (in): center of the Gaussian profile (default [0.,0.,0.])      :ivar x_c: center of the Gaussian profile (default [0.,0.,0.])
78      @ivar A (in): height of the profile. A maybe a vector. (default 1.)      :ivar A: (in) height of the profile. A maybe a vector. (default 1.)
79      @ivar width (in): width of the profile (default 0.1)      :ivar width: (in) width of the profile (default 0.1)
80      @ivar r (in): radius of the circle (default = 0)      :ivar r: (in) radius of the circle (default = 0)
     @ivar out (callable): profile  
81    
82      In the case that the spatial dimension is two, The third component of      In the case that the spatial dimension is two, The third component of
83      x_c is dropped      x_c is dropped.
84      """      """
85      def __init__(self,debug=False):      def __init__(self,**kwargs):
86          ParameterSet.__init__(self,debug=debug)          super(GaussianProfile, self).__init__(**kwargs)
87          self.declareParameter(domain=None,          self.declareParameter(domain=None,
88                                x_c=numarray.zeros([3]),                                x_c=numpy.zeros([3]),
89                                A=1.,                                A=1.,
90                                width=0.1,                                width=0.1,
91                                r=0)                                r=0)
# Line 73  class GaussianProfile(ParameterSet): Line 93  class GaussianProfile(ParameterSet):
93      def out(self):      def out(self):
94          """          """
95          Generate the Gaussian profile          Generate the Gaussian profile
96    
97            Link against this method to get the output of this model.
98          """          """
99          x = self.domain.getX()          x = self.domain.getX()
100          dim = self.domain.getDim()          dim = self.domain.getDim()
101          l = length(x-self.x_c[:dim])          l = length(x-self.x_c[:dim])
102          m = (l-self.r).whereNegative()          m = whereNegative(l-self.r)
103    
104          return (m+(1.-m)*exp(-log(2.)*(l/self.width)**2))*self.A          return (m+(1.-m)*exp(-log(2.)*(l/self.width)**2))*self.A
105    
106  class InterpolateOverBox(ParameterSet):  class InterpolateOverBox(ParameterSet):
107      """      """
108      Returns values at each time. The values are defined through given values      Returns values at each time. The values are defined through given values
109      at time node.      at time node. For two dimensional domains back values are ignored.
110    
111      @ivar domain (in): domain      :ivar domain: domain
112      @ivar left_bottom_front (in): coordinates of left, bottom, front corner      :ivar value_left_bottom_front: (in) value at left,bottom,front corner
113                of the box      :ivar value_right_bottom_front: (in) value at right, bottom, front corner
114      @ivar right_top_back (in): coordinates of the right, top, back corner      :ivar value_left_top_front: (in) value at left,top,front corner
115                of the box      :ivar value_right_top_front: (in) value at right,top,front corner
116      @ivar value_left_bottom_front (in): value at left,bottom,front corner      :ivar value_left_bottom_back: (in) value at  left,bottom,back corner
117      @ivar value_right_bottom_front (in): value at right, bottom, front corner      :ivar value_right_bottom_back: (in) value at right,bottom,back corner
118      @ivar value_left_top_front (in): value at left,top,front corner      :ivar value_left_top_back: (in) value at left,top,back  corner
119      @ivar value_right_top_front (in): value at right,top,front corner      :ivar value_right_top_back: (in) value at right,top,back corner
     @ivar value_left_bottom_back (in): value at  left,bottom,back corner  
     @ivar value_right_bottom_back (in): value at right,bottom,back corner  
     @ivar value_left_top_back (in): value at left,top,back  corner  
     @ivar value_right_top_back (in): value at right,top,back corner  
     @ivar out (callable): values at domain locations by bilinear  
               interpolation.  For two dimensional domains back values are  
               ignored.  
120      """      """
121    
122      def __init__(self, debug=False):      def __init__(self, **kwargs):
123          ParameterSet.__init__(self, debug=debug)          super(InterpolateOverBox, self).__init__(self)
124          self.declareParameter(domain=None,          self.declareParameter(domain=None,
                               left_bottom_front=[0.,0.,0.],  
                               right_top_back=[1.,1.,1.],  
125                                value_left_bottom_front=0.,                                value_left_bottom_front=0.,
126                                value_right_bottom_front=0.,                                value_right_bottom_front=0.,
127                                value_left_top_front=0.,                                value_left_top_front=0.,
# Line 120  class InterpolateOverBox(ParameterSet): Line 133  class InterpolateOverBox(ParameterSet):
133    
134    
135      def out(self):      def out(self):
136            """
137            values at domain locations by bilinear interpolation of the given values.
138    
139            Link against this method to get the output of this model.
140            """
141          x = self.domain.getX()          x = self.domain.getX()
142          if self.domain.getDim() == 2:          if self.domain.getDim() == 2:
143              f_right = (x[0] - self.left_bottom_front[0])/\              x0,x1=x[0],x[1]
144           (self.right_top_back[0] - self.left_bottom_front[0])              left_bottom_front0,right_top_back0=inf(x0),sup(x0)
145                left_bottom_front1,right_top_back1=inf(x1),sup(x1)
146                f_right = (x0 - left_bottom_front0)/(right_top_back0 -left_bottom_front0)
147              f_left = 1. - f_right              f_left = 1. - f_right
148              f_top = (x[1] - self.left_bottom_front[1])/\              f_top = (x1 - left_bottom_front1)/(right_top_back1 - left_bottom_front1)
          (self.right_top_back[1] - self.left_bottom_front[1])  
149              f_bottom = 1. - f_top              f_bottom = 1. - f_top
150              out = self.value_left_bottom_front * f_left * f_bottom \              out = f_left * f_bottom * self.value_left_bottom_front \
151                  + self.value_right_bottom_front* f_right * f_bottom \                  + f_right * f_bottom * self.value_right_bottom_front \
152                  + self.value_left_top_front    * f_left * f_top \                  + f_left * f_top * self.value_left_top_front \
153                  + self.value_right_top_front   * f_right * f_top                  + f_right * f_top * self.value_right_top_front
154          else:          else:
155              f_right = (x[0] - self.left_bottom_front[0])/\              x0,x1,x2=x[0],x[1],x[2]
156                      (self.right_top_back[0] - self.left_bottom_front[0])              left_bottom_front0,right_top_back0=inf(x0),sup(x0)
157                left_bottom_front1,right_top_back1=inf(x1),sup(x1)
158                left_bottom_front2,right_top_back2=inf(x2),sup(x2)
159                f_right = (x0 - left_bottom_front0)/(right_top_back0 - left_bottom_front0)
160              f_left = 1. - f_right              f_left = 1. - f_right
161              f_top = (x[1] - self.left_bottom_front[1])/\              f_top = (x1 - left_bottom_front1)/(right_top_back1 - left_bottom_front1)
                     (self.right_top_back[1] - self.left_bottom_front[1])  
162              f_bottom = 1. - f_top              f_bottom = 1. - f_top
163              f_back = (x[2] - self.left_bottom_front[1])/\              f_back = (x2 - left_bottom_front1)/(right_top_back2 - left_bottom_front2)
                     (self.right_top_back[2] - self.left_bottom_front[2])  
164              f_front = 1. - f_back              f_front = 1. - f_back
165              out = self.value_left_bottom_front * f_left * f_bottom * f_front \              out = f_left * f_bottom * f_front * self.value_left_bottom_front\
166                  + self.value_right_bottom_front* f_right * f_bottom * f_front \                  + f_right * f_bottom * f_front * self.value_right_bottom_front\
167                  + self.value_left_top_front    * f_left * f_top * f_front \                  + f_left * f_top * f_front * self.value_left_top_front\
168                  + self.value_right_top_front   * f_right * f_top * f_front \                  + f_right * f_top * f_front * self.value_right_top_front\
169                  + self.value_left_bottom_back  * f_left * f_bottom * f_back \                  + f_left * f_bottom * f_back * self.value_left_bottom_back\
170                  + self.value_right_bottom_back * f_right * f_bottom * f_back \                  + f_right * f_bottom * f_back * self.value_right_bottom_back\
171                  + self.value_left_top_back     * f_left * f_top * f_back \                  + f_left * f_top * f_back * self.value_left_top_back\
172                  + self.value_right_top_back    * f_right * f_top * f_back                  + f_right * f_top * f_back * self.value_right_top_back
173          return out          return out
174    
175    
# Line 165  class InterpolatedTimeProfile(ParameterS Line 185  class InterpolatedTimeProfile(ParameterS
185         For time t<nodes[0], value[0] is used and for t>nodes[l], values[l]         For time t<nodes[0], value[0] is used and for t>nodes[l], values[l]
186         is used where l=len(nodes)-1.         is used where l=len(nodes)-1.
187    
188         @ivar t (in): current time         :ivar t: (in) current time
189         @ivar node (in): list of time nodes         :ivar node: (in) list of time nodes
190         @ivar values (in): list of values at time nodes         :ivar values: (in) list of values at time nodes
        @ivar out (callable): current value  
191         """         """
192    
193         def __init__(self,debug=False):         def __init__(self,**kwargs):
194             ParameterSet.__init__(self,debug=debug)             super( InterpolatedTimeProfile, self).__init__(**kwargs)
195             self.declareParameter(t=0., \             self.declareParameter(t=0., \
196                                   nodes=[0.,1.],\                                   nodes=[0.,1.],\
197                                   values=[1.,1.])                                   values=[1.,1.])
198         def out(self):         def out(self):
199               """
200               current value
201      
202               Link against this method to get the output of this model.
203               """
204             l = len(self.nodes) - 1             l = len(self.nodes) - 1
205             t = self.t             t = self.t
206             if t <= self.nodes[0]:             if t <= self.nodes[0]:
# Line 189  class InterpolatedTimeProfile(ParameterS Line 213  class InterpolatedTimeProfile(ParameterS
213                        return m*(t-self.nodes[i-1]) + self.values[i-1]                        return m*(t-self.nodes[i-1]) + self.values[i-1]
214                 return self.values[l]                 return self.values[l]
215    
216  class LinearCombination(Model):  class ScalarDistributionFromTags(ParameterSet):
217        """
218        creates a scalar distribution on a domain from tags, If tag_map is given
219        the tags can be given a names and tag_map is used to map it into domain tags.
220                
221        :ivar domain: domain
222        :type domain: `esys.escript.Domain`
223        :ivar default: default value
224        :ivar tag0: tag 0
225        :type tag0: ``int``
226        :ivar value0: value for tag 0
227        :type value0: ``float``
228        :ivar tag1: tag 1
229        :type tag1: ``int``
230        :ivar value1: value for tag 1
231        :type value1: ``float``
232        :ivar tag2: tag 2
233        :type tag2: ``int``
234        :ivar value2: value for tag 2
235        :type value2: ``float``
236        :ivar tag3: tag 3
237        :type tag3: ``int``
238        :ivar value3: value for tag 3
239        :type value3: ``float``
240        :ivar tag4: tag 4
241        :type tag4: ``int``
242        :ivar value4: value for tag 4
243        :type value4: ``float``
244        :ivar tag5: tag 5
245        :type tag5: ``int``
246        :ivar value5: value for tag 5
247        :type value5: ``float``
248        :ivar tag6: tag 6
249        :type tag6: ``int``
250        :ivar value6: value for tag 6
251        :type value6: ``float``
252        :ivar tag7: tag 7
253        :type tag7: ``int``
254        :ivar value7: value for tag 7
255        :type value7: ``float``
256        :ivar tag8: tag 8
257        :type tag8: ``int``
258        :ivar value8: value for tag 8
259        :type value8: ``float``
260        :ivar tag9: tag 9
261        :type tag9: ``int``
262        :ivar value9: value for tag 9
263        :type value9: ``float``
264        """
265        def __init__(self,**kwargs):
266            super(ScalarDistributionFromTags, self).__init__(**kwargs)
267            self.declareParameter(domain=None,
268                                  default=0.,
269                                  tag0=None,
270                                  value0=0.,
271                                  tag1=None,
272                                  value1=0.,
273                                  tag2=None,
274                                  value2=0.,
275                                  tag3=None,
276                                  value3=0.,
277                                  tag4=None,
278                                  value4=0.,
279                                  tag5=None,
280                                  value5=0.,
281                                  tag6=None,
282                                  value6=0.,
283                                  tag7=None,
284                                  value7=0.,
285                                  tag8=None,
286                                  value8=0.,
287                                  tag9=None,
288                                  value9=0.)
289    
290    
291        def out(self):
292            """
293            returns a `esys.escript.Data` object
294            Link against this method to get the output of this model.
295            """
296            d=Scalar(self.default,Function(self.domain))
297            if not self.tag0 == None: d.setTaggedValue(self.tag0,self.value0)
298            if not self.tag1 == None: d.setTaggedValue(self.tag1,self.value1)
299            if not self.tag2 == None: d.setTaggedValue(self.tag2,self.value2)
300            if not self.tag3 == None: d.setTaggedValue(self.tag3,self.value3)
301            if not self.tag4 == None: d.setTaggedValue(self.tag4,self.value4)
302            if not self.tag5 == None: d.setTaggedValue(self.tag5,self.value5)
303            if not self.tag6 == None: d.setTaggedValue(self.tag6,self.value6)
304            if not self.tag7 == None: d.setTaggedValue(self.tag7,self.value7)
305            if not self.tag8 == None: d.setTaggedValue(self.tag8,self.value8)
306            if not self.tag9 == None: d.setTaggedValue(self.tag9,self.value9)
307            return d
308    
309    class SmoothScalarDistributionFromTags(ParameterSet):
310        """
311        creates a smooth scalar distribution on a domain from region tags
312                
313        :ivar domain: domain
314        :type domain: `esys.escript.Domain`
315        :ivar default: default value
316        :ivar tag0: tag 0
317        :type tag0: ``int``
318        :ivar value0: value for tag 0
319        :type value0: ``float``
320        :ivar tag1: tag 1
321        :type tag1: ``int``
322        :ivar value1: value for tag 1
323        :type value1: ``float``
324        :ivar tag2: tag 2
325        :type tag2: ``int``
326        :ivar value2: value for tag 2
327        :type value2: ``float``
328        :ivar tag3: tag 3
329        :type tag3: ``int``
330        :ivar value3: value for tag 3
331        :type value3: ``float``
332        :ivar tag4: tag 4
333        :type tag4: ``int``
334        :ivar value4: value for tag 4
335        :type value4: ``float``
336        :ivar tag5: tag 5
337        :type tag5: ``int``
338        :ivar value5: value for tag 5
339        :type value5: ``float``
340        :ivar tag6: tag 6
341        :type tag6: ``int``
342        :ivar value6: value for tag 6
343        :type value6: ``float``
344        :ivar tag7: tag 7
345        :type tag7: ``int``
346        :ivar value7: value for tag 7
347        :type value7: ``float``
348        :ivar tag8: tag 8
349        :type tag8: ``int``
350        :ivar value8: value for tag 8
351        :type value8: ``float``
352        :ivar tag9: tag 9
353        :type tag9: ``int``
354        :ivar value9: value for tag 9
355        :type value9: ``float``
356        """
357        def __init__(self,**kwargs):
358            super(SmoothScalarDistributionFromTags, self).__init__(**kwargs)
359            self.declareParameter(domain=None,
360                                  default=0.,
361                                  tag0=None,
362                                  value0=0.,
363                                  tag1=None,
364                                  value1=0.,
365                                  tag2=None,
366                                  value2=0.,
367                                  tag3=None,
368                                  value3=0.,
369                                  tag4=None,
370                                  value4=0.,
371                                  tag5=None,
372                                  value5=0.,
373                                  tag6=None,
374                                  value6=0.,
375                                  tag7=None,
376                                  value7=0.,
377                                  tag8=None,
378                                  value8=0.,
379                                  tag9=None,
380                                  value9=0.)
381    
382    
383        def __update(self,tag,tag_value,value):
384            if self.__pde==None:
385               self.__pde=LinearPDE(self.domain,numSolutions=1)
386            mask=Scalar(0.,Function(self.domain))
387            mask.setTaggedValue(tag,1.)
388            self.__pde.setValue(Y=mask)
389            mask=wherePositive(abs(self.__pde.getRightHandSide()))
390            value*=(1.-mask)
391            value+=tag_value*mask
392            return value
393    
394        def out(self):
395            """
396            returns a `esys.escript.Data` object
397            Link against this method to get the output of this model.
398            """
399            d=Scalar(self.default,Solution(self.domain))
400            self.__pde=None
401            if not self.tag0 == None: d=self.__update(self.tag0,self.value0,d)
402            if not self.tag1 == None: d=self.__update(self.tag1,self.value1,d)
403            if not self.tag2 == None: d=self.__update(self.tag2,self.value2,d)
404            if not self.tag3 == None: d=self.__update(self.tag3,self.value3,d)
405            if not self.tag4 == None: d=self.__update(self.tag4,self.value4,d)
406            if not self.tag5 == None: d=self.__update(self.tag5,self.value5,d)
407            if not self.tag6 == None: d=self.__update(self.tag6,self.value6,d)
408            if not self.tag7 == None: d=self.__update(self.tag7,self.value7,d)
409            if not self.tag8 == None: d=self.__update(self.tag8,self.value8,d)
410            if not self.tag9 == None: d=self.__update(self.tag9,self.value9,d)
411            return d
412    
413    class LinearCombination(ParameterSet):
414      """      """
415      Returns a linear combination of the f0*v0+f1*v1+f2*v2+f3*v3+f4*v4      Returns a linear combination of the f0*v0+f1*v1+f2*v2+f3*v3+f4*v4
416                            
417      @ivar f0 (in): numerical object or None (default: None)      :ivar f0: numerical object or None, default=None (in)
418      @ivar v0 (in): numerical object or None (default: None)      :ivar v0: numerical object or None, default=None (in)
419      @ivar f1 (in): numerical object or None (default: None)      :ivar f1: numerical object or None, default=None (in)
420      @ivar v1 (in): numerical object or None (default: None)      :ivar v1: numerical object or None, default=None (in)
421      @ivar f2 (in): numerical object or None (default: None)      :ivar f2: numerical object or None, default=None (in)
422      @ivar v2 (in): numerical object or None (default: None)      :ivar v2: numerical object or None, default=None (in)
423      @ivar f3 (in): numerical object or None (default: None)      :ivar f3: numerical object or None, default=None (in)
424      @ivar v3 (in): numerical object or None (default: None)      :ivar v3: numerical object or None, default=None (in)
425      @ivar f4 (in): numerical object or None (default: None)      :ivar f4: numerical object or None, default=None (in)
426      @ivar v4 (in): numerical object or None (default: None)      :ivar v4: numerical object or None, default=None (in)
     @ivar out (callable): current value  
427      """      """
428      def __init__(self,debug=False):      def __init__(self,**kwargs):
429          Model.__init__(self,debug=debug)          super(LinearCombination, self).__init__(**kwargs)
430          self.declareParameter(f0=None, \          self.declareParameter(f0=None, \
431                                v0=None, \                                v0=None, \
432                                f1=None, \                                f1=None, \
# Line 219  class LinearCombination(Model): Line 439  class LinearCombination(Model):
439                                v4=None)                                v4=None)
440    
441      def out(self):      def out(self):
442            """
443            returns f0*v0+f1*v1+f2*v2+f3*v3+f4*v4.
444            Link against this method to get the output of this model.
445            """
446          if not self.f0 == None and not self.v0 == None:          if not self.f0 == None and not self.v0 == None:
447              fv0 = self.f0*self.v0              fv0 = self.f0*self.v0
448          else:          else:
# Line 256  class LinearCombination(Model): Line 480  class LinearCombination(Model):
480              out += fv3              out += fv3
481          return out          return out
482    
483    class MergeConstraints(ParameterSet):
484        """
485        Returns a linear combination of the f0*v0+f1*v1+f2*v2+f3*v3+f4*v4
486        """
487        def __init__(self,**kwargs):
488            super(MergeConstraints, self).__init__(**kwargs)
489            self.declareParameter(location_of_constraint0=None, \
490                                  value_of_constraint0=None, \
491                                  location_of_constraint1=None, \
492                                  value_of_constraint1=None, \
493                                  location_of_constraint2=None, \
494                                  value_of_constraint2=None, \
495                                  location_of_constraint3=None, \
496                                  value_of_constraint3=None, \
497                                  location_of_constraint4=None, \
498                                  value_of_constraint4=None)
499        def location_of_constraint(self):
500              """
501              return the values used to constrain a solution
502    
503              :return: the mask marking the locations of the constraints
504              :rtype: `escript.Scalar`
505              """
506              out_loc=0
507              if not self.location_of_constraint0 == None:
508                   out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint0))
509              if not self.location_of_constraint1 == None:
510                   out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint1))
511              if not self.location_of_constraint2 == None:
512                   out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint2))
513              if not self.location_of_constraint3 == None:
514                   out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint3))
515              return out_loc
516    
517        def value_of_constraint(self):
518              """
519              return the values used to constrain a solution
520    
521              :return: values to be used at the locations of the constraints. If
522                      ``value`` is not given ``None`` is rerturned.
523              :rtype: `escript.Scalar`
524              """
525              out_loc=0
526              out=0
527              if not self.location_of_constraint0 == None:
528                   tmp=wherePositive(self.location_of_constraint0)
529                   out=out*(1.-tmp)+self.value_of_constraint0*tmp
530                   out_loc=wherePositive(out_loc+tmp)
531              if not self.location_of_constraint1 == None:
532                   tmp=wherePositive(self.location_of_constraint1)
533                   out=out*(1.-tmp)+self.value_of_constraint1*tmp
534                   out_loc=wherePositive(out_loc+tmp)
535              if not self.location_of_constraint2 == None:
536                   tmp=wherePositive(self.location_of_constraint2)
537                   out=out*(1.-tmp)+self.value_of_constraint2*tmp
538                   out_loc=wherePositive(out_loc+tmp)
539              if not self.location_of_constraint3 == None:
540                   tmp=wherePositive(self.location_of_constraint3)
541                   out=out*(1.-tmp)+self.value_of_constraint3*tmp
542                   out_loc=wherePositive(out_loc+tmp)
543              return out
544  # vim: expandtab shiftwidth=4:  # vim: expandtab shiftwidth=4:

Legend:
Removed from v.149  
changed lines
  Added in v.2625

  ViewVC Help
Powered by ViewVC 1.1.26