/[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 127 by jgs, Fri Jul 22 05:11:29 2005 UTC trunk/modellib/py_src/input.py revision 819 by gross, Sun Aug 27 23:07:51 2006 UTC
# Line 1  Line 1 
1  # $Id$  # $Id$
2    
3    __copyright__="""  Copyright (c) 2006 by ACcESS MNRF
4                        http://www.access.edu.au
5                    Primary Business: Queensland, Australia"""
6    __license__="""Licensed under the Open Software License version 3.0
7                 http://www.opensource.org/licenses/osl-3.0.php"""
8    
 from esys.modelframe import Model  
9  from esys.escript import *  from esys.escript import *
10    from esys.escript.modelframe import Model,ParameterSet
11  from math import log  from math import log
12    
13    class Sequencer(Model):
14        """
15        Runs through time until t_end is reached.
16    
17        @ivar t_end: model is terminated when t_end is passed, default 1 (in).
18        @type t_end: C{float}
19        @ivar dt_max: maximum time step size, default L{Model.UNDEF_DT} (in)
20        @type dt_max: C{float}
21        @ivar t: current time stamp (in/out). By default it is initialized with zero.
22        @type t: C{float}
23    
24  class GausseanProfile(Model):      """
25      """@brief generates a gaussean profile at center x_c, width width and height A over a domain      def __init__(self,debug=False):
26            """
27            """
28            super(Sequencer,self).__init__(debug=debug)
29            self.declareParameter(t=0.,
30                                  t_end=1.,
31                                  dt_max=Model.UNDEF_DT)
32    
33        def doInitialization(self):
34            """
35            initialize time integration
36            """
37            self.__t_old = self.t
38    
39        def doStepPreprocessing(self, dt):
40            self.t = self.__t_old+dt
41    
42        def doStepPostprocessing(self, dt):
43            self.__t_old = self.t
44    
45        def finalize(self):
46            """
47            returns true when L{t} has reached L{t_end}
48            """
49            return self.t >= self.t_end
50    
51        def getSafeTimeStepSize(self, dt):
52            """
53            returns L{dt_max}
54            """
55            return self.dt_max
56    
57             @param domain (in) - domain  class GaussianProfile(ParameterSet):
58             @param x_c (in)  - center of the Gaussean profile (default [0.,0.,0.])      """
59             @param A (in)  - height of the profile. A maybe a vector. (default 1.)      Generates a Gaussian profile at center x_c, width width and height A
60             @param width (in) - width of the profile (default 0.1)      over a domain
            @param r (in) -  radius of the circle (default = 0)  
            @param out (out) - profile  
61    
62        @ivar domain: domain
63        @ivar x_c: center of the Gaussian profile (default [0.,0.,0.])
64        @ivar A: (in) height of the profile. A maybe a vector. (default 1.)
65        @ivar width: (in) width of the profile (default 0.1)
66        @ivar r: (in) radius of the circle (default = 0)
67    
68         In the case that the spatial dimension is two, The third component of x_c is dropped      In the case that the spatial dimension is two, The third component of
69        x_c is dropped.
70      """      """
71      def __init__(self,debug=False):      def __init__(self,debug=False):
72          Model.__init__(self,debug=debug)          ParameterSet.__init__(self,debug=debug)
73          self.declareParameter(domain=None, x_c=numarray.zeros([3]),A=1.,width=0.1,r=0)          self.declareParameter(domain=None,
74                                  x_c=numarray.zeros([3]),
75                                  A=1.,
76                                  width=0.1,
77                                  r=0)
78    
79      def out(self):      def out(self):
80          x=self.domain.getX()          """
81          dim=self.domain.getDim()          Generate the Gaussian profile
82          l=length(x-self.x_c[:dim])  
83          m=(l-self.r).whereNegative()          Link against this method to get the output of this model.
84            """
85            x = self.domain.getX()
86            dim = self.domain.getDim()
87            l = length(x-self.x_c[:dim])
88            m = whereNegative(l-self.r)
89    
90          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
91    
92  class InterpolatedTimeProfile(Model):  class InterpolateOverBox(ParameterSet):
93         """ """      """
94        Returns values at each time. The values are defined through given values
95        at time node. For two dimensional domains back values are ignored.
96    
97        @ivar domain: domain
98        @ivar value_left_bottom_front: (in) value at left,bottom,front corner
99        @ivar value_right_bottom_front: (in) value at right, bottom, front corner
100        @ivar value_left_top_front: (in) value at left,top,front corner
101        @ivar value_right_top_front: (in) value at right,top,front corner
102        @ivar value_left_bottom_back: (in) value at  left,bottom,back corner
103        @ivar value_right_bottom_back: (in) value at right,bottom,back corner
104        @ivar value_left_top_back: (in) value at left,top,back  corner
105        @ivar value_right_top_back: (in) value at right,top,back corner
106        """
107    
108        def __init__(self, debug=False):
109            ParameterSet.__init__(self, debug=debug)
110            self.declareParameter(domain=None,
111                                  value_left_bottom_front=0.,
112                                  value_right_bottom_front=0.,
113                                  value_left_top_front=0.,
114                                  value_right_top_front=0.,
115                                  value_left_bottom_back=0.,
116                                  value_right_bottom_back=0.,
117                                  value_left_top_back=0.,
118                                  value_right_top_back=0.)
119    
120    
121        def out(self):
122            """
123            values at domain locations by bilinear interpolation of the given values.
124    
125            Link against this method to get the output of this model.
126            """
127            x = self.domain.getX()
128            if self.domain.getDim() == 2:
129                x0,x1=x[0],x[1]
130                left_bottom_front0,right_top_back0=inf(x0),sup(x0)
131                left_bottom_front1,right_top_back1=inf(x[1]),sup(x[1])
132                f_right = (x[0] - self.left_bottom_front0)/\
133             (self.right_top_back0 - self.left_bottom_front0)
134                f_left = 1. - f_right
135                f_top = (x[1] - self.left_bottom_front1)/\
136             (self.right_top_back1 - self.left_bottom_front1)
137                f_bottom = 1. - f_top
138                out = f_left * f_bottom * self.value_left_bottom_front \
139                    + f_right * f_bottom * self.value_right_bottom_front \
140                    + f_left * f_top * self.value_left_top_front \
141                    + f_right * f_top * self.value_right_top_front
142            else:
143                x0,x1,x2=x[0],x[1],x[2]
144                left_bottom_front0,right_top_back0=inf(x0),sup(x0)
145                left_bottom_front1,right_top_back1=inf(x[1]),sup(x[1])
146                left_bottom_front2,right_top_back2=inf(x[2]),sup(x[2])
147                f_right = (x[0] - self.left_bottom_front0)/\
148                        (self.right_top_back0 - self.left_bottom_front0)
149                f_left = 1. - f_right
150                f_top = (x[1] - self.left_bottom_front1)/\
151                        (self.right_top_back1 - self.left_bottom_front1)
152                f_bottom = 1. - f_top
153                f_back = (x[2] - self.left_bottom_front1)/\
154                        (self.right_top_back2 - self.left_bottom_front2)
155                f_front = 1. - f_back
156                out = f_left * f_bottom * f_front * self.value_left_bottom_front\
157                    + f_right * f_bottom * f_front * self.value_right_bottom_front\
158                    + f_left * f_top * f_front * self.value_left_top_front\
159                    + f_right * f_top * f_front * self.value_right_top_front\
160                    + f_left * f_bottom * f_back * self.value_left_bottom_back\
161                    + f_right * f_bottom * f_back * self.value_right_bottom_back\
162                    + f_left * f_top * f_back * self.value_left_top_back\
163                    + f_right * f_top * f_back * self.value_right_top_back
164            return out
165    
166    
167    class InterpolatedTimeProfile(ParameterSet):
168           """
169    
170           Returns values at each time. The values are defined through given
171           values at time node.
172                
173           value[i] defines the value at time nodes[i]. Between nodes linear
174           interpolation is used.
175    
176           For time t<nodes[0], value[0] is used and for t>nodes[l], values[l]
177           is used where l=len(nodes)-1.
178    
179           @ivar t: (in) current time
180           @ivar node: (in) list of time nodes
181           @ivar values: (in) list of values at time nodes
182           """
183    
184         def __init__(self,debug=False):         def __init__(self,debug=False):
185             Model.__init__(self,debug=debug)             ParameterSet.__init__(self,debug=debug)
186             self.declareParameter(t=[0.,1.],\             self.declareParameter(t=0., \
187                                   values=[1.,1.],\                                   nodes=[0.,1.],\
188                                   out=0.)                                   values=[1.,1.])
189         def doInitialization(self,t):         def out(self):
190             self.__tn=t             """
191               current value
192         def doStep(self,dt):    
193              t=self.__tn+dt             Link against this method to get the output of this model.
194              if t<=self.t[0]:             """
195                  self.out=self.values[0]             l = len(self.nodes) - 1
196              else:             t = self.t
197                 for i in range(1,len(self.t)):             if t <= self.nodes[0]:
198                    if t<self.t[i]:                 return self.values[0]
199                      m=(self.values[i-1]-self.values[i])/(self.t[i-1]-self.t[i])             else:
200                      self.out=m*(t-self.t[i-1])+self.values[i-1]                 for i in range(1,l):
201                 self.out=self.t[len(self.t)-1]                    if t < self.nodes[i]:
202              self.__tn+=dt                        m = (self.values[i-1] - self.values[i])/\
203                                (self.nodes[i-1] - self.nodes[i])
204                          return m*(t-self.nodes[i-1]) + self.values[i-1]
205                   return self.values[l]
206    
207    class LinearCombination(Model):
208        """
209        Returns a linear combination of the f0*v0+f1*v1+f2*v2+f3*v3+f4*v4
210                
211        @ivar f0: numerical object or None, default=None (in)
212        @ivar v0: numerical object or None, default=None (in)
213        @ivar f1: numerical object or None, default=None (in)
214        @ivar v1: numerical object or None, default=None (in)
215        @ivar f2: numerical object or None, default=None (in)
216        @ivar v2: numerical object or None, default=None (in)
217        @ivar f3: numerical object or None, default=None (in)
218        @ivar v3: numerical object or None, default=None (in)
219        @ivar f4: numerical object or None, default=None (in)
220        @ivar v4: numerical object or None, default=None (in)
221        """
222        def __init__(self,debug=False):
223            Model.__init__(self,debug=debug)
224            self.declareParameter(f0=None, \
225                                  v0=None, \
226                                  f1=None, \
227                                  v1=None, \
228                                  f2=None, \
229                                  v2=None, \
230                                  f3=None, \
231                                  v3=None, \
232                                  f4=None, \
233                                  v4=None)
234    
235        def out(self):
236            """
237            returns f0*v0+f1*v1+f2*v2+f3*v3+f4*v4.
238            Link against this method to get the output of this model.
239            """
240            if not self.f0 == None and not self.v0 == None:
241                fv0 = self.f0*self.v0
242            else:
243                fv0 = None
244    
245            if not self.f1 == None and not self.v1 == None:
246                fv1 = self.f1*self.v1
247            else:
248                fv1 = None
249    
250            if not self.f2 == None and not self.v2 == None:
251                fv2 = f2*v2
252            else:
253                fv2 = None
254    
255            if not self.f3 == None and not self.v3 == None:
256                fv3 = self.f3*self.v3
257            else:
258                fv3 = None
259    
260            if not self.f4 == None and not self.v4 == None:
261                fv4 = self.f4*self.v4
262            else:
263                fv4 = None
264    
265            if fv0 == None:
266                 out = 0.
267            else:
268                 out = fv0
269            if not fv1 == None:
270                out += fv1
271            if not fv2 == None:
272                out += fv2
273            if not fv3 == None:
274                out += fv3
275            return out
276    
277    # vim: expandtab shiftwidth=4:

Legend:
Removed from v.127  
changed lines
  Added in v.819

  ViewVC Help
Powered by ViewVC 1.1.26