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.Scalar}
          """
          out_loc=0
          if not self.location_of_constraint0 == None:
               out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint0))
          if not self.location_of_constraint1 == None:
               out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint1))
          if not self.location_of_constraint2 == None:
               out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint2))
          if not self.location_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.Scalar}
          """
          out_loc=0
          out=0
          if not self.location_of_constraint0 == None:
               tmp=wherePositive(self.location_of_constraint0)
               out=out*(1.-tmp)+self.value_of_constraint0*tmp
               out_loc=wherePositive(out_loc+tmp)
          if not self.location_of_constraint1 == None:
               tmp=wherePositive(self.location_of_constraint1)
               out=out*(1.-tmp)+self.value_of_constraint1*tmp
               out_loc=wherePositive(out_loc+tmp)
          if not self.location_of_constraint2 == None:
               tmp=wherePositive(self.location_of_constraint2)
               out=out*(1.-tmp)+self.value_of_constraint2*tmp
               out_loc=wherePositive(out_loc+tmp)
          if not self.location_of_constraint3 == None:
               tmp=wherePositive(self.location_of_constraint3)
               out=out*(1.-tmp)+self.value_of_constraint3*tmp
               out_loc=wherePositive(out_loc+tmp)
          return out
# vim: expandtab shiftwidth=4:
1	# $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
9	from esys.escript import *
10	from esys.escript.modelframe import Model,ParameterSet
11	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	"""
25	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	class GaussianProfile(ParameterSet):
58	"""
59	Generates a Gaussian profile at center x_c, width width and height A
60	over a domain
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
69	x_c is dropped.
70	"""
71	def __init__(self,debug=False):
72	ParameterSet.__init__(self,debug=debug)
73	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):
80	"""
81	Generate the Gaussian profile
82
83	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
91
92	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(x1),sup(x1)
132	f_right = (x0 - left_bottom_front0)/(right_top_back0 -left_bottom_front0)
133	f_left = 1. - f_right
134	f_top = (x1 - left_bottom_front1)/(right_top_back1 - left_bottom_front1)
135	f_bottom = 1. - f_top
136	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	else:
141	x0,x1,x2=x[0],x[1],x[2]
142	left_bottom_front0,right_top_back0=inf(x0),sup(x0)
143	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	f_left = 1. - f_right
147	f_top = (x1 - left_bottom_front1)/(right_top_back1 - left_bottom_front1)
148	f_bottom = 1. - f_top
149	f_back = (x2 - left_bottom_front1)/(right_top_back2 - left_bottom_front2)
150	f_front = 1. - f_back
151	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	return out
160
161
162	class InterpolatedTimeProfile(ParameterSet):
163	"""
164
165	Returns values at each time. The values are defined through given
166	values at time node.
167
168	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
174	@ivar t: (in) current time
175	@ivar node: (in) list of time nodes
176	@ivar values: (in) list of values at time nodes
177	"""
178
179	def __init__(self,debug=False):
180	ParameterSet.__init__(self,debug=debug)
181	self.declareParameter(t=0., \
182	nodes=[0.,1.],\
183	values=[1.,1.])
184	def out(self):
185	"""
186	current value
187
188	Link against this method to get the output of this model.
189	"""
190	l = len(self.nodes) - 1
191	t = self.t
192	if t <= self.nodes[0]:
193	return self.values[0]
194	else:
195	for i in range(1,l):
196	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	return self.values[l]
201
202	class ScalarDistributionFromTags(ParameterSet):
203	"""
204	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	super(ScalarDistributionFromTags, self).__init__(debug=debug)
252	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	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	return d
293
294	class LinearCombination(ParameterSet):
295	"""
296	Returns a linear combination of the f0v0+f1v1+f2v2+f3v3+f4*v4
297
298	@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	"""
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
322	def out(self):
323	"""
324	returns f0v0+f1v1+f2v2+f3v3+f4*v4.
325	Link against this method to get the output of this model.
326	"""
327	if not self.f0 == None and not self.v0 == None:
328	fv0 = self.f0*self.v0
329	else:
330	fv0 = None
331
332	if not self.f1 == None and not self.v1 == None:
333	fv1 = self.f1*self.v1
334	else:
335	fv1 = None
336
337	if not self.f2 == None and not self.v2 == None:
338	fv2 = f2*v2
339	else:
340	fv2 = None
341
342	if not self.f3 == None and not self.v3 == None:
343	fv3 = self.f3*self.v3
344	else:
345	fv3 = None
346
347	if not self.f4 == None and not self.v4 == None:
348	fv4 = self.f4*self.v4
349	else:
350	fv4 = None
351
352	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
364	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.Scalar}
386	"""
387	out_loc=0
388	if not self.location_of_constraint0 == None:
389	out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint0))
390	if not self.location_of_constraint1 == None:
391	out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint1))
392	if not self.location_of_constraint2 == None:
393	out_loc=wherePositive(out_loc+wherePositive(self.location_of_constraint2))
394	if not self.location_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.Scalar}
405	"""
406	out_loc=0
407	out=0
408	if not self.location_of_constraint0 == None:
409	tmp=wherePositive(self.location_of_constraint0)
410	out=out(1.-tmp)+self.value_of_constraint0tmp
411	out_loc=wherePositive(out_loc+tmp)
412	if not self.location_of_constraint1 == None:
413	tmp=wherePositive(self.location_of_constraint1)
414	out=out(1.-tmp)+self.value_of_constraint1tmp
415	out_loc=wherePositive(out_loc+tmp)
416	if not self.location_of_constraint2 == None:
417	tmp=wherePositive(self.location_of_constraint2)
418	out=out(1.-tmp)+self.value_of_constraint2tmp
419	out_loc=wherePositive(out_loc+tmp)
420	if not self.location_of_constraint3 == None:
421	tmp=wherePositive(self.location_of_constraint3)
422	out=out(1.-tmp)+self.value_of_constraint3tmp
423	out_loc=wherePositive(out_loc+tmp)
424	return out
425	# vim: expandtab shiftwidth=4:
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision