modellib/py_src/input.py

# $Id$

__copyright__="""  Copyright (c) 2006 by ACcESS MNRF
                    http://www.access.edu.au
                Primary Business: Queensland, Australia"""
__license__="""Licensed under the Open Software License version 3.0
             http://www.opensource.org/licenses/osl-3.0.php"""

from esys.escript import *
from esys.escript.modelframe import Model,ParameterSet
from math import log

class Sequencer(Model):
    """
    Runs through time until t_end is reached. 

    @ivar t_end: model is terminated when t_end is passed, default 1 (in).
    @type t_end: C{float}
    @ivar dt_max: maximum time step size, default L{Model.UNDEF_DT} (in)
    @type dt_max: C{float}
    @ivar t: current time stamp (in/out). By default it is initialized with zero.
    @type t: C{float}

    """
    def __init__(self,debug=False):
        """
        """
        super(Sequencer,self).__init__(debug=debug)
        self.declareParameter(t=0.,
                              t_end=1.,
                              dt_max=Model.UNDEF_DT)

    def doInitialization(self):
        """ 
        initialize time integration
        """
        self.__t_old = self.t

    def doStepPreprocessing(self, dt):
        self.t = self.__t_old+dt

    def doStepPostprocessing(self, dt):
        self.__t_old = self.t

    def finalize(self):
        """
        returns true when L{t} has reached L{t_end}
        """
        return self.t >= self.t_end

    def getSafeTimeStepSize(self, dt):
        """
        returns L{dt_max}
        """
        return self.dt_max

class GaussianProfile(ParameterSet):
    """
    Generates a Gaussian profile at center x_c, width width and height A 
    over a domain

    @ivar domain: domain
    @ivar x_c: center of the Gaussian profile (default [0.,0.,0.])
    @ivar A: (in) height of the profile. A maybe a vector. (default 1.)
    @ivar width: (in) width of the profile (default 0.1)
    @ivar r: (in) radius of the circle (default = 0)

    In the case that the spatial dimension is two, The third component of 
    x_c is dropped.
    """
    def __init__(self,debug=False):
        ParameterSet.__init__(self,debug=debug)
        self.declareParameter(domain=None, 
                              x_c=numarray.zeros([3]),
                              A=1.,
                              width=0.1,
                              r=0)

    def out(self):
        """
        Generate the Gaussian profile

        Link against this method to get the output of this model.
        """
        x = self.domain.getX()
        dim = self.domain.getDim()
        l = length(x-self.x_c[:dim])
        m = whereNegative(l-self.r)

        return (m+(1.-m)*exp(-log(2.)*(l/self.width)**2))*self.A

class InterpolateOverBox(ParameterSet):
    """
    Returns values at each time. The values are defined through given values 
    at time node. For two dimensional domains back values are ignored.

    @ivar domain: domain
    @ivar value_left_bottom_front: (in) value at left,bottom,front corner
    @ivar value_right_bottom_front: (in) value at right, bottom, front corner
    @ivar value_left_top_front: (in) value at left,top,front corner
    @ivar value_right_top_front: (in) value at right,top,front 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
    """

    def __init__(self, debug=False):
        ParameterSet.__init__(self, debug=debug)
        self.declareParameter(domain=None, 
                              value_left_bottom_front=0.,
                              value_right_bottom_front=0.,
                              value_left_top_front=0.,
                              value_right_top_front=0.,
                              value_left_bottom_back=0.,
                              value_right_bottom_back=0.,
                              value_left_top_back=0.,
                              value_right_top_back=0.)


    def out(self):
        """
        values at domain locations by bilinear interpolation of the given values.

        Link against this method to get the output of this model.
        """
        x = self.domain.getX()
        if self.domain.getDim() == 2:
            x0,x1=x[0],x[1]
            left_bottom_front0,right_top_back0=inf(x0),sup(x0)
            left_bottom_front1,right_top_back1=inf(x1),sup(x1)
            f_right = (x0 - left_bottom_front0)/(right_top_back0 -left_bottom_front0)
            f_left = 1. - f_right
            f_top = (x1 - left_bottom_front1)/(right_top_back1 - left_bottom_front1)
            f_bottom = 1. - f_top
            out = f_left * f_bottom * self.value_left_bottom_front \
                + f_right * f_bottom * self.value_right_bottom_front \
                + f_left * f_top * self.value_left_top_front \
                + f_right * f_top * self.value_right_top_front
        else:
            x0,x1,x2=x[0],x[1],x[2]
            left_bottom_front0,right_top_back0=inf(x0),sup(x0)
            left_bottom_front1,right_top_back1=inf(x1),sup(x1)
            left_bottom_front2,right_top_back2=inf(x2),sup(x2)
            f_right = (x0 - left_bottom_front0)/(right_top_back0 - left_bottom_front0)
            f_left = 1. - f_right
            f_top = (x1 - left_bottom_front1)/(right_top_back1 - left_bottom_front1)
            f_bottom = 1. - f_top
            f_back = (x2 - left_bottom_front1)/(right_top_back2 - left_bottom_front2)
            f_front = 1. - f_back
            out = f_left * f_bottom * f_front * self.value_left_bottom_front\
                + f_right * f_bottom * f_front * self.value_right_bottom_front\
                + f_left * f_top * f_front * self.value_left_top_front\
                + f_right * f_top * f_front * self.value_right_top_front\
                + f_left * f_bottom * f_back * self.value_left_bottom_back\
                + f_right * f_bottom * f_back * self.value_right_bottom_back\
                + f_left * f_top * f_back * self.value_left_top_back\
                + f_right * f_top * f_back * self.value_right_top_back
        return out


class InterpolatedTimeProfile(ParameterSet):
       """

       Returns values at each time. The values are defined through given 
       values at time node.
            
       value[i] defines the value at time nodes[i]. Between nodes linear 
       interpolation is used.

       For time t<nodes[0], value[0] is used and for t>nodes[l], values[l] 
       is used where l=len(nodes)-1.
 
       @ivar t: (in) current time
       @ivar node: (in) list of time nodes
       @ivar values: (in) list of values at time nodes
       """

       def __init__(self,debug=False):
           ParameterSet.__init__(self,debug=debug)
           self.declareParameter(t=0., \
                                 nodes=[0.,1.],\
                                 values=[1.,1.])
       def out(self):
           """
           current value
  
           Link against this method to get the output of this model.
           """
           l = len(self.nodes) - 1
           t = self.t
           if t <= self.nodes[0]:
               return self.values[0]
           else:
               for i in range(1,l):
                  if t < self.nodes[i]:
                      m = (self.values[i-1] - self.values[i])/\
                            (self.nodes[i-1] - self.nodes[i])
                      return m*(t-self.nodes[i-1]) + self.values[i-1]
               return self.values[l]

class ScalarDistributionFromTags(ParameterSet):
    """
    creates a scalar distribution on a domain from tags
            
    @ivar domain: domain
    @type domain: L{esys.escript.Domain}
    @ivar default: default value 
    @ivar tag0: tag 0
    @type tag0: C{int}
    @ivar value0: value for tag 0
    @type value0: C{float}
    @ivar tag1: tag 1
    @type tag1: C{int}
    @ivar value1: value for tag 1
    @type value1: C{float}
    @ivar tag2: tag 2
    @type tag2: C{int}
    @ivar value2: value for tag 2
    @type value2: C{float}
    @ivar tag3: tag 3
    @type tag3: C{int}
    @ivar value3: value for tag 3
    @type value3: C{float}
    @ivar tag4: tag 4
    @type tag4: C{int}
    @ivar value4: value for tag 4
    @type value4: C{float}
    @ivar tag5: tag 5
    @type tag5: C{int}
    @ivar value5: value for tag 5
    @type value5: C{float}
    @ivar tag6: tag 6
    @type tag6: C{int}
    @ivar value6: value for tag 6
    @type value6: C{float}
    @ivar tag7: tag 7
    @type tag7: C{int}
    @ivar value7: value for tag 7
    @type value7: C{float}
    @ivar tag8: tag 8
    @type tag8: C{int}
    @ivar value8: value for tag 8
    @type value8: C{float}
    @ivar tag9: tag 9
    @type tag9: C{int}
    @ivar value9: value for tag 9
    @type value9: C{float}
    """
    def __init__(self,debug=False):
        super(ScalarDistributionFromTags, self).__init__(debug=debug)
        self.declareParameter(domain=None,
                              default=0.,
                              tag0=None,
                              value0=0.,
                              tag1=None,
                              value1=0.,
                              tag2=None,
                              value2=0.,
                              tag3=None,
                              value3=0.,
                              tag4=None,
                              value4=0.,
                              tag5=None,
                              value5=0.,
                              tag6=None,
                              value6=0.,
                              tag7=None,
                              value7=0.,
                              tag8=None,
                              value8=0.,
                              tag9=None,
                              value9=0.)


    def out(self):
        """
        returns a L{esys.escript.Data} object
        Link against this method to get the output of this model.
        """
        d=Scalar(self.default,Function(self.domain))
        if not self.tag0 == None: d.setTaggedValue(self.tag0,self.value0)
        if not self.tag1 == None: d.setTaggedValue(self.tag1,self.value1)
        if not self.tag2 == None: d.setTaggedValue(self.tag2,self.value2)
        if not self.tag3 == None: d.setTaggedValue(self.tag3,self.value3)
        if not self.tag4 == None: d.setTaggedValue(self.tag4,self.value4)
        if not self.tag5 == None: d.setTaggedValue(self.tag5,self.value5)
        if not self.tag6 == None: d.setTaggedValue(self.tag6,self.value6)
        if not self.tag7 == None: d.setTaggedValue(self.tag7,self.value7)
        if not self.tag8 == None: d.setTaggedValue(self.tag8,self.value8)
        if not self.tag9 == None: d.setTaggedValue(self.tag9,self.value9)
        return d

class LinearCombination(ParameterSet):
    """
    Returns a linear combination of the f0*v0+f1*v1+f2*v2+f3*v3+f4*v4
            
    @ivar f0: numerical object or None, default=None (in)
    @ivar v0: numerical object or None, default=None (in)
    @ivar f1: numerical object or None, default=None (in)
    @ivar v1: numerical object or None, default=None (in)
    @ivar f2: numerical object or None, default=None (in)
    @ivar v2: numerical object or None, default=None (in)
    @ivar f3: numerical object or None, default=None (in)
    @ivar v3: numerical object or None, default=None (in)
    @ivar f4: numerical object or None, default=None (in)
    @ivar v4: numerical object or None, default=None (in)
    """
    def __init__(self,debug=False):
        Model.__init__(self,debug=debug)
        self.declareParameter(f0=None, \
                              v0=None, \
                              f1=None, \
                              v1=None, \
                              f2=None, \
                              v2=None, \
                              f3=None, \
                              v3=None, \
                              f4=None, \
                              v4=None)

    def out(self):
        """
        returns f0*v0+f1*v1+f2*v2+f3*v3+f4*v4.
        Link against this method to get the output of this model.
        """
        if not self.f0 == None and not self.v0 == None:
            fv0 = self.f0*self.v0
        else:
            fv0 = None

        if not self.f1 == None and not self.v1 == None:
            fv1 = self.f1*self.v1
        else:
            fv1 = None

        if not self.f2 == None and not self.v2 == None:
            fv2 = f2*v2
        else:
            fv2 = None

        if not self.f3 == None and not self.v3 == None:
            fv3 = self.f3*self.v3
        else:
            fv3 = None

        if not self.f4 == None and not self.v4 == None:
            fv4 = self.f4*self.v4
        else:
            fv4 = None

        if fv0 == None: 
             out = 0.
        else:
             out = fv0
        if not fv1 == None: 
            out += fv1
        if not fv2 == None: 
            out += fv2
        if not fv3 == None: 
            out += fv3
        return out

class MergeConstraints(ParameterSet):
    """
    Returns a linear combination of the f0*v0+f1*v1+f2*v2+f3*v3+f4*v4
    """
    def __init__(self,debug=False):
        super(MergeConstraints, self).__init__(debug=debug)
        self.declareParameter(location_of_constraint0=None, \
                              value_of_constraint0=None, \
                              location_of_constraint1=None, \
                              value_of_constraint1=None, \
                              location_of_constraint2=None, \
                              value_of_constraint2=None, \
                              location_of_constraint3=None, \
                              value_of_constraint3=None, \
                              location_of_constraint4=None, \
                              value_of_constraint4=None)
    def location_of_constraint(self):
          """
          return the values used to constrain a solution

          @return: the mask marking the locations of the constraints
          @rtype: L{escript.Vector}
          """
          out_loc=0
          if not self.location_of_constraint0 == None and not self.value_of_constraint0== None:
               out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint0))
          if not self.location_of_constraint1 == None and not self.value_of_constraint1== None:
               out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint1))
          if not self.location_of_constraint2 == None and not self.value_of_constraint2== None:
               out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint2))
          if not self.location_of_constraint3 == None and not self.value_of_constraint3== None:
               out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint3))
          return out_loc

    def value_of_constraint(self):
          """
          return the values used to constrain a solution

          @return: values to be used at the locations of the constraints. If
                  L{value} is not given C{None} is rerturned.
          @rtype: L{escript.Vector}
          """
          out_loc=0
          out=0
          if not self.location_of_constraint0 == None and not self.value_of_constraint0== None:
               tmp=wherePositive(self.location_of_constraint0)
               out=out*out_loc+self.value_of_constraint0*tmp
               out_loc=wherePositive(out_loc+tmp)
          if not self.location_of_constraint1 == None and not self.value_of_constraint1== None:
               tmp=wherePositive(self.location_of_constraint1)
               out=out*out_loc+self.value_of_constraint1*tmp
               out_loc=wherePositive(out_loc+tmp)
          if not self.location_of_constraint2 == None and not self.value_of_constraint2== None:
               tmp=wherePositive(self.location_of_constraint2)
               out=out*out_loc+self.value_of_constraint2*tmp
               out_loc=wherePositive(out_loc+tmp)
          if not self.location_of_constraint3 == None and not self.value_of_constraint3== None:
               tmp=wherePositive(self.location_of_constraint3)
               out=out*out_loc+self.value_of_constraint3*tmp
               out_loc=wherePositive(out_loc+tmp)
          return out
# vim: expandtab shiftwidth=4:
1	jgs	127	# $Id$
2	elspeth	628
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
9	jgs	149	from esys.escript import *
10			from esys.escript.modelframe import Model,ParameterSet
11	jgs	147	from math import log
12	jgs	127
13	jgs	147	class Sequencer(Model):
14	jgs	148	"""
15	gross	814	Runs through time until t_end is reached.
16	gross	720
17	gross	814	@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	jgs	148	"""
25	gross	423	def __init__(self,debug=False):
26	jgs	148	"""
27	jgs	149	"""
28	gross	423	super(Sequencer,self).__init__(debug=debug)
29			self.declareParameter(t=0.,
30			t_end=1.,
31			dt_max=Model.UNDEF_DT)
32	jgs	127
33	jgs	147	def doInitialization(self):
34	jgs	148	"""
35	jgs	149	initialize time integration
36	jgs	148	"""
37			self.__t_old = self.t
38	jgs	147
39	jgs	148	def doStepPreprocessing(self, dt):
40			self.t = self.__t_old+dt
41	jgs	147
42	jgs	148	def doStepPostprocessing(self, dt):
43			self.__t_old = self.t
44	jgs	147
45			def finalize(self):
46	jgs	148	"""
47	gross	814	returns true when L{t} has reached L{t_end}
48	jgs	148	"""
49			return self.t >= self.t_end
50	jgs	147
51	jgs	148	def getSafeTimeStepSize(self, dt):
52			"""
53	gross	814	returns L{dt_max}
54	jgs	148	"""
55			return self.dt_max
56	jgs	147
57	jgs	148	class GaussianProfile(ParameterSet):
58			"""
59	jgs	149	Generates a Gaussian profile at center x_c, width width and height A
60	jgs	148	over a domain
61	jgs	127
62	gross	814	@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	jgs	127
68	jgs	148	In the case that the spatial dimension is two, The third component of
69	gross	814	x_c is dropped.
70	jgs	127	"""
71			def __init__(self,debug=False):
72	jgs	148	ParameterSet.__init__(self,debug=debug)
73	jgs	147	self.declareParameter(domain=None,
74			x_c=numarray.zeros([3]),
75			A=1.,
76			width=0.1,
77			r=0)
78	jgs	127
79			def out(self):
80	jgs	149	"""
81			Generate the Gaussian profile
82	gross	814
83			Link against this method to get the output of this model.
84	jgs	149	"""
85	jgs	148	x = self.domain.getX()
86			dim = self.domain.getDim()
87			l = length(x-self.x_c[:dim])
88	gross	323	m = whereNegative(l-self.r)
89	jgs	148
90	jgs	127	return (m+(1.-m)exp(-log(2.)(l/self.width)*2))self.A
91
92	jgs	148	class InterpolateOverBox(ParameterSet):
93	jgs	147	"""
94	jgs	148	Returns values at each time. The values are defined through given values
95	gross	814	at time node. For two dimensional domains back values are ignored.
96	jgs	147
97	gross	814	@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	jgs	147	"""
107
108	jgs	148	def __init__(self, debug=False):
109			ParameterSet.__init__(self, debug=debug)
110	jgs	147	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	gross	814	"""
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	jgs	148	x = self.domain.getX()
128			if self.domain.getDim() == 2:
129	gross	819	x0,x1=x[0],x[1]
130			left_bottom_front0,right_top_back0=inf(x0),sup(x0)
131	gross	820	left_bottom_front1,right_top_back1=inf(x1),sup(x1)
132			f_right = (x0 - left_bottom_front0)/(right_top_back0 -left_bottom_front0)
133	jgs	148	f_left = 1. - f_right
134	gross	820	f_top = (x1 - left_bottom_front1)/(right_top_back1 - left_bottom_front1)
135	jgs	148	f_bottom = 1. - f_top
136	gross	816	out = f_left * f_bottom * self.value_left_bottom_front \
137			+ f_right * f_bottom * self.value_right_bottom_front \
138			+ f_left * f_top * self.value_left_top_front \
139			+ f_right * f_top * self.value_right_top_front
140	jgs	147	else:
141	gross	819	x0,x1,x2=x[0],x[1],x[2]
142			left_bottom_front0,right_top_back0=inf(x0),sup(x0)
143	gross	820	left_bottom_front1,right_top_back1=inf(x1),sup(x1)
144			left_bottom_front2,right_top_back2=inf(x2),sup(x2)
145			f_right = (x0 - left_bottom_front0)/(right_top_back0 - left_bottom_front0)
146	jgs	148	f_left = 1. - f_right
147	gross	820	f_top = (x1 - left_bottom_front1)/(right_top_back1 - left_bottom_front1)
148	jgs	148	f_bottom = 1. - f_top
149	gross	820	f_back = (x2 - left_bottom_front1)/(right_top_back2 - left_bottom_front2)
150	jgs	148	f_front = 1. - f_back
151	gross	816	out = f_left * f_bottom * f_front * self.value_left_bottom_front\
152			+ f_right * f_bottom * f_front * self.value_right_bottom_front\
153			+ f_left * f_top * f_front * self.value_left_top_front\
154			+ f_right * f_top * f_front * self.value_right_top_front\
155			+ f_left * f_bottom * f_back * self.value_left_bottom_back\
156			+ f_right * f_bottom * f_back * self.value_right_bottom_back\
157			+ f_left * f_top * f_back * self.value_left_top_back\
158			+ f_right * f_top * f_back * self.value_right_top_back
159	jgs	147	return out
160
161
162	jgs	148	class InterpolatedTimeProfile(ParameterSet):
163			"""
164
165			Returns values at each time. The values are defined through given
166			values at time node.
167	jgs	147
168	jgs	148	value[i] defines the value at time nodes[i]. Between nodes linear
169			interpolation is used.
170
171			For time t<nodes[0], value[0] is used and for t>nodes[l], values[l]
172			is used where l=len(nodes)-1.
173	jgs	147
174	gross	814	@ivar t: (in) current time
175			@ivar node: (in) list of time nodes
176			@ivar values: (in) list of values at time nodes
177	jgs	148	"""
178	jgs	127
179			def __init__(self,debug=False):
180	jgs	148	ParameterSet.__init__(self,debug=debug)
181	jgs	147	self.declareParameter(t=0., \
182			nodes=[0.,1.],\
183			values=[1.,1.])
184			def out(self):
185	gross	814	"""
186			current value
187
188			Link against this method to get the output of this model.
189			"""
190	jgs	148	l = len(self.nodes) - 1
191			t = self.t
192			if t <= self.nodes[0]:
193			return self.values[0]
194	jgs	147	else:
195			for i in range(1,l):
196	jgs	148	if t < self.nodes[i]:
197			m = (self.values[i-1] - self.values[i])/\
198			(self.nodes[i-1] - self.nodes[i])
199			return m*(t-self.nodes[i-1]) + self.values[i-1]
200	jgs	147	return self.values[l]
201	jgs	127
202	gross	903	class ScalarDistributionFromTags(ParameterSet):
203	jgs	148	"""
204	gross	903	creates a scalar distribution on a domain from tags
205
206			@ivar domain: domain
207			@type domain: L{esys.escript.Domain}
208			@ivar default: default value
209			@ivar tag0: tag 0
210			@type tag0: C{int}
211			@ivar value0: value for tag 0
212			@type value0: C{float}
213			@ivar tag1: tag 1
214			@type tag1: C{int}
215			@ivar value1: value for tag 1
216			@type value1: C{float}
217			@ivar tag2: tag 2
218			@type tag2: C{int}
219			@ivar value2: value for tag 2
220			@type value2: C{float}
221			@ivar tag3: tag 3
222			@type tag3: C{int}
223			@ivar value3: value for tag 3
224			@type value3: C{float}
225			@ivar tag4: tag 4
226			@type tag4: C{int}
227			@ivar value4: value for tag 4
228			@type value4: C{float}
229			@ivar tag5: tag 5
230			@type tag5: C{int}
231			@ivar value5: value for tag 5
232			@type value5: C{float}
233			@ivar tag6: tag 6
234			@type tag6: C{int}
235			@ivar value6: value for tag 6
236			@type value6: C{float}
237			@ivar tag7: tag 7
238			@type tag7: C{int}
239			@ivar value7: value for tag 7
240			@type value7: C{float}
241			@ivar tag8: tag 8
242			@type tag8: C{int}
243			@ivar value8: value for tag 8
244			@type value8: C{float}
245			@ivar tag9: tag 9
246			@type tag9: C{int}
247			@ivar value9: value for tag 9
248			@type value9: C{float}
249			"""
250			def __init__(self,debug=False):
251	gross	904	super(ScalarDistributionFromTags, self).__init__(debug=debug)
252	gross	903	self.declareParameter(domain=None,
253			default=0.,
254			tag0=None,
255			value0=0.,
256			tag1=None,
257			value1=0.,
258			tag2=None,
259			value2=0.,
260			tag3=None,
261			value3=0.,
262			tag4=None,
263			value4=0.,
264			tag5=None,
265			value5=0.,
266			tag6=None,
267			value6=0.,
268			tag7=None,
269			value7=0.,
270			tag8=None,
271			value8=0.,
272			tag9=None,
273			value9=0.)
274
275
276			def out(self):
277			"""
278			returns a L{esys.escript.Data} object
279			Link against this method to get the output of this model.
280			"""
281			d=Scalar(self.default,Function(self.domain))
282	gross	904	if not self.tag0 == None: d.setTaggedValue(self.tag0,self.value0)
283			if not self.tag1 == None: d.setTaggedValue(self.tag1,self.value1)
284			if not self.tag2 == None: d.setTaggedValue(self.tag2,self.value2)
285			if not self.tag3 == None: d.setTaggedValue(self.tag3,self.value3)
286			if not self.tag4 == None: d.setTaggedValue(self.tag4,self.value4)
287			if not self.tag5 == None: d.setTaggedValue(self.tag5,self.value5)
288			if not self.tag6 == None: d.setTaggedValue(self.tag6,self.value6)
289			if not self.tag7 == None: d.setTaggedValue(self.tag7,self.value7)
290			if not self.tag8 == None: d.setTaggedValue(self.tag8,self.value8)
291			if not self.tag9 == None: d.setTaggedValue(self.tag9,self.value9)
292	gross	903	return d
293
294			class LinearCombination(ParameterSet):
295			"""
296	jgs	148	Returns a linear combination of the f0v0+f1v1+f2v2+f3v3+f4*v4
297	jgs	147
298	gross	819	@ivar f0: numerical object or None, default=None (in)
299			@ivar v0: numerical object or None, default=None (in)
300			@ivar f1: numerical object or None, default=None (in)
301			@ivar v1: numerical object or None, default=None (in)
302			@ivar f2: numerical object or None, default=None (in)
303			@ivar v2: numerical object or None, default=None (in)
304			@ivar f3: numerical object or None, default=None (in)
305			@ivar v3: numerical object or None, default=None (in)
306			@ivar f4: numerical object or None, default=None (in)
307			@ivar v4: numerical object or None, default=None (in)
308	jgs	148	"""
309			def __init__(self,debug=False):
310			Model.__init__(self,debug=debug)
311			self.declareParameter(f0=None, \
312			v0=None, \
313			f1=None, \
314			v1=None, \
315			f2=None, \
316			v2=None, \
317			f3=None, \
318			v3=None, \
319			f4=None, \
320			v4=None)
321	jgs	147
322	jgs	148	def out(self):
323	gross	814	"""
324			returns f0v0+f1v1+f2v2+f3v3+f4*v4.
325			Link against this method to get the output of this model.
326			"""
327	jgs	148	if not self.f0 == None and not self.v0 == None:
328			fv0 = self.f0*self.v0
329			else:
330			fv0 = None
331	jgs	147
332	jgs	148	if not self.f1 == None and not self.v1 == None:
333			fv1 = self.f1*self.v1
334			else:
335			fv1 = None
336	jgs	147
337	jgs	148	if not self.f2 == None and not self.v2 == None:
338			fv2 = f2*v2
339			else:
340			fv2 = None
341	jgs	147
342	jgs	148	if not self.f3 == None and not self.v3 == None:
343			fv3 = self.f3*self.v3
344			else:
345			fv3 = None
346	jgs	147
347	jgs	148	if not self.f4 == None and not self.v4 == None:
348			fv4 = self.f4*self.v4
349			else:
350			fv4 = None
351	jgs	147
352	jgs	148	if fv0 == None:
353			out = 0.
354			else:
355			out = fv0
356			if not fv1 == None:
357			out += fv1
358			if not fv2 == None:
359			out += fv2
360			if not fv3 == None:
361			out += fv3
362			return out
363	jgs	147
364	gross	904	class MergeConstraints(ParameterSet):
365			"""
366			Returns a linear combination of the f0v0+f1v1+f2v2+f3v3+f4*v4
367			"""
368			def __init__(self,debug=False):
369			super(MergeConstraints, self).__init__(debug=debug)
370			self.declareParameter(location_of_constraint0=None, \
371			value_of_constraint0=None, \
372			location_of_constraint1=None, \
373			value_of_constraint1=None, \
374			location_of_constraint2=None, \
375			value_of_constraint2=None, \
376			location_of_constraint3=None, \
377			value_of_constraint3=None, \
378			location_of_constraint4=None, \
379			value_of_constraint4=None)
380			def location_of_constraint(self):
381			"""
382			return the values used to constrain a solution
383
384			@return: the mask marking the locations of the constraints
385			@rtype: L{escript.Vector}
386			"""
387			out_loc=0
388			if not self.location_of_constraint0 == None and not self.value_of_constraint0== None:
389			out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint0))
390			if not self.location_of_constraint1 == None and not self.value_of_constraint1== None:
391			out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint1))
392			if not self.location_of_constraint2 == None and not self.value_of_constraint2== None:
393			out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint2))
394			if not self.location_of_constraint3 == None and not self.value_of_constraint3== None:
395			out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint3))
396			return out_loc
397
398			def value_of_constraint(self):
399			"""
400			return the values used to constrain a solution
401
402			@return: values to be used at the locations of the constraints. If
403			L{value} is not given C{None} is rerturned.
404			@rtype: L{escript.Vector}
405			"""
406			out_loc=0
407			out=0
408			if not self.location_of_constraint0 == None and not self.value_of_constraint0== None:
409			tmp=wherePositive(self.location_of_constraint0)
410			out=outout_loc+self.value_of_constraint0tmp
411			out_loc=wherePositive(out_loc+tmp)
412			if not self.location_of_constraint1 == None and not self.value_of_constraint1== None:
413			tmp=wherePositive(self.location_of_constraint1)
414			out=outout_loc+self.value_of_constraint1tmp
415			out_loc=wherePositive(out_loc+tmp)
416			if not self.location_of_constraint2 == None and not self.value_of_constraint2== None:
417			tmp=wherePositive(self.location_of_constraint2)
418			out=outout_loc+self.value_of_constraint2tmp
419			out_loc=wherePositive(out_loc+tmp)
420			if not self.location_of_constraint3 == None and not self.value_of_constraint3== None:
421			tmp=wherePositive(self.location_of_constraint3)
422			out=outout_loc+self.value_of_constraint3tmp
423			out_loc=wherePositive(out_loc+tmp)
424			return out
425	jgs	148	# vim: expandtab shiftwidth=4:
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision