/[escript]/trunk/escript/py_src/modelframe.py
ViewVC logotype

Annotation of /trunk/escript/py_src/modelframe.py

Parent Directory Parent Directory | Revision Log Revision Log


Revision 121 - (hide annotations)
Fri May 6 04:26:16 2005 UTC (13 years, 11 months ago) by jgs
Original Path: trunk/esys2/escript/py_src/modelframe.py
File MIME type: text/x-python
File size: 28170 byte(s)
Merge of development branch back to main trunk on 2005-05-06

1 jgs 121 # $Id$
2     from types import StringType
3    
4     class Link:
5     """ """
6     def __init__(self,object,attribute=None):
7     self.__object=object
8     self.setAttributeName(attribute)
9    
10     def setAttributeName(self,name):
11     if not name==None:
12     if not hasattr(self.__object,name):
13     raise AttributeError("Link: object %s has no attribute %s."%(self.__object,name))
14     self.__attribute=name
15    
16     def hasAttributeName(self):
17     if self.__attribute==None:
18     return False
19     else:
20     return True
21    
22     def __str__(self):
23     if self.hasAttributeName():
24     return "reference to %s of %s"%(self.__attribute,self.__object)
25     else:
26     return "reference to object %s"%self.__object
27    
28     def getValue(self,name=None):
29     if not self.hasAttributeName():
30     out=getattr(self.__object,name)
31     else:
32     out=getattr(self.__object,self.__attribute)
33     if callable(out):
34     return out()
35     else:
36     return out
37    
38     class Model:
39     """ the Model class provides a framework to run a time-dependent simulation. A Model has a set of parameter which
40     may be fixed or altered by the Model itself or other Models over time.
41    
42     The parameters of a models are declared at instantion, e.g.
43    
44     m=Model({"message" : "none" })
45    
46     creates a Model with parameters p1 and p2 with inital values 1 and 2. Typically a particular model is defined as a subclass of Model:
47    
48     class Messenger(Model):
49     def __init__(self):
50     Model.__init__(self,parameters={"message" : "none" })
51    
52     m=MyModel()
53    
54     There are various ways how model parameters can be changed:
55    
56     1) use object attributes:
57    
58     m.message="Hello World!"
59    
60     2) use setParamter method
61    
62    
63     m.setParameters(message="Hello World!")
64    
65     3) or dictonaries
66    
67     d={ message : "Hello World!" }
68     m.setParameters(**d)
69    
70    
71     A model executed buy staring the run method of the model:
72    
73     m=Messenger()
74     m.run()
75    
76     The run methods marches through time. It first calls the
77     doInitialization() method of the Model to set up the process. In each time step the doStep() method is called
78     to get from the current to the next time step. The step size is defined by calling the getSafeTimeStepSize() method.
79     The time integration process is terminated when the finalize() methods return true. Final the doFinalization() method
80     is called to finalize the process. To implement a particular model a subclass
81     of the Model class is defined. The subclass overwrites the default methods of Model.
82    
83     The following class defines a messenger printing in the doStep method what ever the current value of its parameter message is:
84    
85     class Messenger(Model):
86     def __init__(self):
87     Model.__init__(self,parameters={"message" : "none" })
88    
89     def doInitialization(self):
90     print "I start talking now!"
91    
92     def doStep(self,t):
93     print "Message (time %e) : %s "%(t,self.message)
94    
95     def doFinalization(self):
96     print "I have no more to say!"
97    
98     If a instance of the Messenger class is run, it will print the initialization and finalization message only.
99     This is because the default method for finalize() does always returns True and therefore the transition is
100     terminated startcht away.
101    
102     Following example for solving the ODE using a forward euler scheme:
103    
104     u(t=0)=u0
105     u_t=a*u**2 for all 0<t<=ten
106    
107     exact solution is given by u(t)=1/(1/u0-a*t)
108    
109     class Ode1(Model):
110     def __init__(self,**args):
111     Model.__init__(self,parameters={"tend" : 1., "dt" : 0.0001 ,"a" : 0.1 ,"u" : 1. },name="test",debug=True)
112    
113     def doInitialization(self):
114     self._tn=0
115    
116     def doStep(self,t):
117     self.u=self.u+(t-self._tn)*self.a*self.u**2
118     self._tn=t
119    
120     def doFinalization(self):
121     print "all done final error = ",abs(self.u-1./(1./3.-self.a*self._tn))
122    
123     def getSafeTimeStepSize(self):
124     return self.dt
125    
126     def finalize(self):
127     return self._tn>=self.tend
128    
129     In some cases at a given time step an iteration process has to be performed to get the state of the Model for the next time step. `
130     In this case the doStep() method is replaced by a sequance of methods which implements this iterative process.
131     The method then will control the iteration process by initializing the iteration through calling the
132     doIterationInitialization() method. The iteration is preformed by calling the doIterationStep() method until
133     the terminate() method returns True. The doIterationFinalization() method is called to end the iteration.
134     For a particular model these methods have to overwritten by a suitable subclass without touching the doStep() method.
135    
136     following example is a modification of the example above. Here an implicit euler scheme is used. in each time step the problem
137    
138     0= u_{n+1}-u_{n}+a*dt*u_{n+1}**2
139    
140     has to be solved for u_{n+1}. The Newton scheme is used to solve this non-linear problem.
141    
142    
143     class Ode2(Model):
144    
145     def __init__(self,**args):
146     Model.__init__(self,{"tend" : 1., "dt" : 0.1 ,"a" : 10. ,"u" : 1. , "tol " : 1.e-8},"test","bla",None,True)
147    
148     def doInitialization(self):
149     self.__tn=0
150    
151     def doIterationInitialization(self,t):
152     self.__iter=0
153     self.u_last=self.u
154     self.current_dt=t-self.tn
155     self.__tn=t
156    
157     def doIterationStep(self):
158     self.__iter+=1
159     self.u_old=self.u
160     self.u=(self.current_dt*self.a*self.u**2-self.u_last)/(2*self.current_dt*self.a*self.u-1.)
161    
162     def terminate(self):
163     return abs(self.u_old-self.u)<self.tol*abs(self.u)
164    
165     def doIterationFinalization(self)
166     print "all done"
167    
168     def getSafeTimeStepSize(self):
169     return self.dt
170    
171     def finalize(self):
172     return self.__tn>self.tend
173    
174     A model can be composed from submodels. Submodels are treated as model parameters. If a model parameter is set or a value of
175     a model parameter is requested, the model will search for this parameter its submodels in the case the model does not have this
176     parameter itself. The order in which the submodels are searched is critical. By default a Model initializes all its submodels,
177     is finalized when all its submodels are finalized and finalizes all its submodels. In the case an iterative process is applied
178     on a particular time step the iteration is initialized for all submodels, then the iteration step is performed for each submodel
179     until all submodels indicate termination. Then the iteration is finalized for all submodels. Finally teh doStop() method for all
180     submethods is called.
181    
182     Here we are creating a model which groups ab instantiation of the Ode2 and the Messenger Model
183    
184     o=Ode2()
185     m=Messenger()
186     om=Model(submodels=[o,m],debug=True)
187     om.dt=0.01
188     om.u=1.
189     m.message="it's me!"
190     om.run()
191    
192     Notice that dt and u are parameters of class Ode2 and message is a parameter of the Messenger class. The Model formed from these models
193     automatically hand the assignment of new values down to the submodel. om.run() starts this combined model where now the soStep() method
194     of the Messenger object printing the value of its parameter message together with a time stamp is executed in each time step introduced
195     by the Ode2 model.
196    
197     A parameter of a Model can be linked to an attribute of onother object, typically an parameter of another Model object.
198    
199    
200     which is comprised by a set of submodels.
201     The simulation is run through its run method which in the simplest case has the form:
202    
203     s=Model()
204     s.run()
205    
206     The run has an initializion and finalization phase. The latter is called if all submodels are to be finalized. The
207     simulation is processing in time through calling the stepForward methods which updates the observables of each submodel.
208     A time steps size which is save for all submodel is choosen.
209    
210     At given time step an iterative process may be performed to make sure that all observables are consistent across all submodels.
211     In this case, similar the time dependence, an initialization and finalization of the iteration is performed.
212    
213     A Model has input and output parameters where each input parameter can be constant, time dependent or may depend on an
214     output parameter of another model or the model itself. To create a parameter name of a model and to
215     assign a value to it one can use the statement
216    
217     model.name=object
218    
219    
220     At any time the current value of the parameter name can be obtained by
221    
222     value=model.name
223    
224     If the object that has been assigned to the paramter/attribute name has the attribute/parameter name isself the current value of this
225     attribute of the object is returned (e.g. for model.name=object where object has an attribute name, the statement value=model.name whould assign
226     the value object.name to value.). If the name of the parameters of a model and an object don't match the setParameter method of model can be used. So
227    
228     model.setParameter(name,object,name_for_object)
229    
230     links the parameter name of model with the parameter name_for_object of object.
231    
232     The run method initiates checkpointing (it is not clear how to do this yet)
233     =====
234    
235     """
236     # step size used in case of an undefined value for the step size
237     UNDEF_DT=1.e300
238    
239     def __init__(self,submodels=[],parameters={},name="model",description="none",check_pointing=None,debug=False):
240     """initiates a model from a list of submodels. """
241     self.setDebug(debug)
242     self.__check_pointing=check_pointing
243     self.__parameters={}
244     self.setName(name)
245     self.setDescription(description)
246     self.declareParameter(**parameters)
247     # get the models defined in parameters:
248     self.__submodels=[]
249     # submodels==None means no submodels used:
250     if submodels==None:
251     pass
252     # no submodel list given means all submodels are used as defined by the parameters dictionary:
253     elif len(submodels)==0:
254     for i in parameters.keys():
255     if isinstance(parameters[i],Model): self.__submodels.append(i)
256     # submodel list of strings and Models is given, submodels defines the order in which the
257     # submodels are processed. if new models are found in the list they are added to the parameter dictionary.
258     else:
259     c=0
260     for i in submodels:
261     if isinstance(i,StringType):
262     m=self.getParameter(i)
263     if not isinstance(m,Model):
264     raise ValueError,"submodel %s is not a model."%i
265     else:
266     if not isinstance(i,Model):
267     raise ValueError,"submodel list does contain item which is not a Model class object."
268     m=i
269     i="__submodel%d__"%c
270     self.declareParameter(**{i : m})
271     c+=1
272     self.__submodels.append(i)
273     if self.debug(): print "%s: model %s is added as parameter %s."%(self,m,i)
274     if len(self.__submodels)>0 and self.debug(): print "%s: model ordering is %s"%(self,self.__submodels)
275     def setSubmodelOrder(submodels=[]):
276     """sets a new ordering for submodels"""
277    
278    
279     #
280     # some basic fuctions:
281     #
282     def debugOn(self):
283     """sets debugging to on"""
284     self.__debug=True
285     def debugOff(self):
286     """sets debugging to off"""
287     self.__debug=False
288     def debug(self):
289     """returns True if debug mode is set to on"""
290     return self.__debug
291     def setDebug(self,flag=False):
292     """sets debugging to flag"""
293     if flag:
294     self.debugOn()
295     else:
296     self.debugOff()
297     def setDebug(self,flag=False):
298     """sets debugging to flag"""
299     if flag:
300     self.debugOn()
301     else:
302     self.debugOff()
303     # name and description handling
304     def __str__(self):
305     """returns the name of the model"""
306     return self.getName()
307    
308     def getName(self):
309     """returns the name of the model"""
310     return self.__name
311    
312     def getFullName(self):
313     """returns the full name of the model including all the names of the submodels"""
314     out=str(self)+"("
315     notfirst=False
316     for i in self.__submodels:
317     if notfirst: out=out+","
318     out=out+i.getFullName()
319     notfirst=True
320     return out+")"
321    
322     def setName(self,name):
323     """sets the name of the model"""
324     self.__name=name
325    
326     def setDescription(self,description="none"):
327     """sets new description"""
328     self.__description=description
329     if self.debug(): print "%s: description is set to %s."%(self,description)
330     def getDescription(self):
331     """returns the description of the model"""
332     return self.__description
333     #
334     # parameter/attribute handling:
335     #
336     def declareParameter(self,**parameters):
337     """declares a new parameter and its inital value."""
338     for prm in parameters.keys():
339     if prm in self.__dict__.keys():
340     raise ValueError,"object attribute %s of %s cannot be used as a model parameter."%(prm,self)
341     self.__parameters[prm]=parameters[prm]
342     if self.debug(): print "%s: parameter %s has been declared."%(self,prm)
343    
344    
345    
346     def showParameters(self):
347     """returns a descrition of the parameters"""
348     out=""
349     notfirst=False
350     for i in self.__parameters:
351     if notfirst: out=out+","
352     notfirst=True
353     out="%s%s=%s"%(out,i,self.__parameters[i])
354     return out
355    
356    
357     def deleteParameter(self,name):
358     """removes parameter name from the model"""
359     raise IllegalParameterError("Cannot delete parameter %s."%name)
360    
361     def getParameter(self,name):
362     """returns the value of parameter name. If the parameter is not declared in self, the submodels are searched.
363     if the parameter is a Link, the current value of the obejective is returned."""
364     if self.__parameters.has_key(name):
365     if isinstance(self.__parameters[name],Link):
366     out=self.__parameters[name].getValue(name)
367     else:
368     out=self.__parameters[name]
369     else:
370     out=None
371     for i in self.__submodels:
372     try:
373     out=self.__parameters[i].getParameter(name)
374     except IllegalParameterError:
375     pass
376     if out==None: raise IllegalParameterError("Cannot find parameter %s."%name)
377     return out
378    
379     def setParameter(self,**parameters):
380     """sets parameter name to value. If the initial value for the parameter is a Model, the new value has to be a Model."""
381     for name in parameters.keys():
382     if self.__parameters.has_key(name):
383     if not isinstance(parameters[name],Model) and isinstance(self.__parameters[name],Model):
384     raise ValueError,"%s: parameter %s can assigned to a Model object only."%(self,name)
385     if isinstance(parameters[name],Model) and not isinstance(self.__parameters[name],Model):
386     raise ValueError,"%s: parameter %s is not declared as a Model."%(self,name)
387     self.__parameters[name]=parameters[name]
388     if isinstance(self.__parameters[name],Link):
389     if not self.__parameters[name].hasAttributeName(): self.__parameters[name].setAttributeName(name)
390     if self.debug(): print "%s: parameter %s has now value %s"%(self,name,self.__parameters[name])
391     else:
392     set=False
393     for i in self.__submodels:
394     try:
395     self.__parameters[i].setParameter(**{name : parameters[name]})
396     set=True
397     except IllegalParameterError:
398     pass
399     if not set: raise IllegalParameterError("%s: Attempt to set undeclared parameter %s."%(self,name))
400    
401     def hasParameter(self,name):
402     """returns True if self or one of the submodels has parameter name"""
403     if self.__parameters.has_key(name):
404     out=True
405     else:
406     out=False
407     for i in self.__submodels: out= out or self.__parameters[i].hasParameter(name)
408     return out
409    
410     def checkParameter(self,name):
411     """checks if self has the parameter name. Otherewise ParameterError is thrown."""
412     if not self.hasParameter(name):
413     raise ParameterError("%s has no parameter %s."%(str(self),name))
414    
415     def __getattr__(self,name):
416     """returns the value for attribute name. If name is in the Link list, the corresponding attribute is returned."""
417     if self.__dict__.has_key(name):
418     return self.__dict__[name]
419     elif self.__dict__.has_key("_Model__parameters") and self.__dict__.has_key("_Model__submodels"):
420     return self.getParameter(name)
421     else:
422     raise AttributeError,"No attribute %s."%name
423    
424     def __setattr__(self,name,value):
425     """returns the value for attribute name."""
426     if self.__dict__.has_key("_Model__parameters") and self.__dict__.has_key("_Model__submodels"):
427     if self.hasParameter(name):
428     self.setParameter(**{ name : value })
429     else:
430     self.__dict__[name]=value
431     else:
432     self.__dict__[name]=value
433    
434     def __delattr__(self,name):
435     """removes the attribute name."""
436     if self.__dict__.has_key(name):
437     del self.__dict__[name]
438     elif self.__dict__.has_key("_Model__parameters"):
439     self.deleteParameter(name)
440     else:
441     raise AttributeError,"No attribute %s."%name
442    
443     #
444     # submodel handeling:
445     #
446     def doInitializationOfSubmodels(self):
447     """initializes the time stepping for all submodels."""
448     for i in self.__submodels: self.getParameter(i).doInitialization()
449    
450     def getSafeTimeStepSizeFromSubmodels(self):
451     """returns a time step size which can savely be used by all submodels. To avoid a big increase in the step size,
452     the new step size is restricted to the double of the precious step size."""
453     out=None
454     for i in self.__submodels:
455     dt=self.getParameter(i).getSafeTimeStepSize()
456     if not dt==None:
457     if out==None:
458     out=dt
459     else:
460     out=min(out,dt)
461     return out
462    
463     def doStepOfSubmodels(self,t):
464     """executes the time step for each submodel"""
465     for i in self.__submodels: self.getParameter(i).doStep(t)
466    
467     def finalizeAllSubmodels(self):
468     """returns True if all submodels can be finalized"""
469     out=True
470     for i in self.__submodels: out = out and self.getParameter(i).finalize()
471     return out
472    
473     def doFinalizationOfSubmodels(self):
474     """finalalizes the time stepping for each of the submodels."""
475     for i in self.__submodels: self.getParameter(i).doFinalization()
476    
477     def doIterationInitializationOfSubmodels(self,t):
478     """initializes the iteration for each of the submodels."""
479     for i in self.__submodels: self.getParameter(i).doIterationInitialization(t)
480    
481     def doIterationStepOfSubmodels(self):
482     """executes the iteration step at time step for each submodel"""
483     for i in self.__submodels: self.getParameter(i).doIterationStep()
484    
485     def terminateAllSubmodels(self):
486     """returns True if all iterations for all submodels are terminated."""
487     out=True
488     for i in self.__submodels: out = out and self.getParameter(i).terminate()
489     return out
490    
491     def doIterationFinalizationOfSubmodels(self):
492     """finalalizes the iteration process for each of the submodels."""
493     for i in self.__submodels: self.getParameter(i).doIterationFinalization()
494    
495     def checkPointSubmodels(self):
496     """performs check pointing for each submodel"""
497     for i in self.__submodels: self.getParameter(i).checkPoint()
498    
499     #
500     # these methods control the time stepping
501     #
502     def doInitialization(self):
503     """initializes the time stepping"""
504     self.doInitializationOfSubmodels()
505    
506     def getSafeTimeStepSize(self):
507     """returns a time step size which can savely be used"""
508     return self.getSafeTimeStepSizeFromSubmodels()
509    
510     def doStep(self,t):
511     """executes the time step by first iterating over time step t and then step forward"""
512     # run iteration on simulation until terminated:
513     self.doIterationInitialization(t)
514     while not self.terminate(): self.doIterationStep()
515     self.doIterationFinalization()
516     self.doStepOfSubmodels(t)
517    
518     def finalize(self):
519     """returns True if all submodels are to be finalized"""
520     return self.finalizeAllSubmodels()
521    
522     def doFinalization(self):
523     """finalizes the time stepping."""
524     self.doFinalizationOfSubmodels()
525     #
526     # methods deal with iterations:
527     #
528     def doIterationInitialization(self,t):
529     """initializes the iteration on a time step"""
530     self.__iter=0
531     if self.debug(): print "%s: iteration starts"%self
532     self.doIterationInitializationOfSubmodels(t)
533    
534     def doIterationStep(self):
535     """executes the iteration step"""
536     self.__iter+=1
537     if self.debug(): print "%s: iteration step %d"%(self,self.__iter)
538     try:
539     self.doIterationStepOfSubmodels()
540     except IterationDivergenceError,e:
541     raise IterationDivergenceError("divergence at time step %s in iteration step %s by reason: \n%s."%(self.__n,self.__iter,e.value))
542    
543     def terminate(self):
544     """returns True if time steping is terminated"""
545     return self.terminateAllSubmodels()
546    
547     def doIterationFinalization(self):
548     """finalalizes the iteration process."""
549     self.doIterationFinalizationOfSubmodels()
550     if self.debug(): print "%s: iteration finalized after %s step"%(self,self.__iter)
551     #
552     # sum other method:
553     #
554     def checkPoint(self):
555     """performs check pointing for each submodel"""
556     if not self.__check_pointing==None:
557     if self.__n%self.__check_pointing==0: self.checkPointsSubmodels()
558    
559     def run(self):
560     """After check_pointing time steps the model will start to create checkpoint files for each of the submodels"""
561     self.__tn=0.
562     self.__n=0
563     self.__dt=None
564     self.doInitialization()
565     while not self.finalize():
566     self.__n+=1
567     self.__dt=self.getSafeTimeStepSize()
568     if self.__dt==None: self.__dt=self.UNDEF_DT
569     if self.debug(): print "%s: %d. time step %e (step size %e.)"%(self,self.__n,self.__tn+self.__dt,self.__dt)
570     endoftimestep=False
571     while not endoftimestep:
572     endoftimestep=True
573     try:
574     self.doStep(self.__tn+self.__dt)
575     except FailedTimeStepError:
576     self.__dt=self.getSafeTimeStepSize()
577     if self.__dt==None: self.__dt=self.UNDEF_DT
578     endoftimestep=False
579     if self.debug(): print "%s: time step is repeated with new step size %e."%(self,self.__dt)
580     except IterationDivergenceError:
581     self.__dt*=0.5
582     endoftimestep=False
583     if self.debug(): print "%s: iteration failes. time step is repeated with new step size %e."%(self,self.__dt)
584     self.checkPoint()
585     self.__tn+=self.__dt
586     self.doFinalization()
587    
588     class IterationDivergenceError(Exception):
589     """excpetion which should be thrown if an iteration at a time step fails"""
590     pass
591    
592     class FailedTimeStepError(Exception):
593     """excpetion which should be thrown if the time step fails because of a step size that have been choosen to be to large"""
594     pass
595    
596     class IllegalParameterError(Exception):
597     """excpetion which is thrown if model has not the desired parameter"""
598     pass
599    
600    
601     if __name__=="__main__":
602     class Messenger(Model):
603     def __init__(self):
604     Model.__init__(self,parameters={"message" : "none" },name="messenger")
605    
606     def doInitialization(self):
607     print "I start talking now!"
608    
609     def doStep(self,t):
610     print "Message (time %e) : %s "%(t,self.message)
611    
612     def doFinalization(self):
613     print "I have no more to say!"
614    
615     # explicit scheme
616     class Ode1(Model):
617     def __init__(self,**args):
618     Model.__init__(self,parameters={"tend" : 1., "dt" : 0.0001 ,"a" : 0.1 ,"u" : 1. , "message" : "none" },name="Ode1",debug=True)
619    
620     def doInitialization(self):
621     self._tn=0
622    
623     def doStep(self,t):
624     self.u=self.u+(t-self._tn)*self.a*self.u**2
625     self._tn=t
626    
627     def doFinalization(self):
628     self.message="current error = %e"%abs(self.u-1./(1./3.-self.a*self._tn))
629     print self.message
630    
631     def getSafeTimeStepSize(self):
632     return self.dt
633    
634     def finalize(self):
635     return self._tn>=self.tend
636     # explicit scheme
637     class Ode2(Model):
638    
639     def __init__(self,**args):
640     Model.__init__(self,parameters={"tend" : 1., "dt" : 0.0001 ,"a" : 0.1 ,"u" : 10000. },name="Ode2",debug=True)
641     self.declareParameter(tol=1.e-8,message="none")
642    
643    
644     def doInitialization(self):
645     self._tn=0
646     self._iter=0
647    
648     def doIterationInitialization(self,t):
649     self._iter=0
650     self._u_last=self.u
651     self._dt=t-self._tn
652     self._tn=t
653    
654     def doIterationStep(self):
655     self._iter+=1
656     self._u_old=self.u
657     self.u=(self._dt*self.a*self.u**2-self._u_last)/(2*self._dt*self.a*self.u-1.)
658    
659     def terminate(self):
660     if self._iter<1:
661     return False
662     else:
663     return abs(self._u_old-self.u)<self.tol*abs(self.u)
664    
665     def doIterationFinalization(self):
666     self.message="current error = %e"%abs(self.u-1./(1-self.a*self._tn))
667     print self.message
668    
669     def getSafeTimeStepSize(self):
670     return self.dt
671    
672     def finalize(self):
673     return self._tn>=self.tend
674    
675     # a simple model with paramemter tend, dt, p1, p2, and p3
676     class Test1(Model):
677    
678     def __init__(self,**args):
679     Model.__init__(self,{"tend" : 1., "dt" : 0.1 ,"p1" : 0 ,"p2" : 0 ,"p3" : 0 },"test","bla",None,True)
680     self.setParameters(args)
681    
682     def doInitialization(self):
683     self.__tn=0
684     self.__n=0
685    
686     def doStep(self,t):
687     self.p3=self.p1+t*self.p2
688     self.__tn=t
689     print "test1 set the value out1 to ",self.p3
690    
691     def doFinalization(self):
692     pass
693    
694     def getSafeTimeStepSize(self):
695     return self.dt
696    
697     def finalize(self):
698     return self._tn>self.tend
699    
700    
701     class Test2(Model):
702    
703     def __init__(self):
704     Model.__init__(self,{"q1": None},"test2","",None,True)
705    
706    
707     def doInitialization(self):
708     print "the whole thing starts"
709    
710     def doStep(self,t):
711     print "test2 things that out1 is now ",self.out1
712    
713     def doFinalization(self):
714     print "all done"
715    
716     def finalize(self):
717     return True
718    
719     class Test12(Model):
720     """model build from two models in a transperent way"""
721     def __init__(self):
722     Model.__init__(self,{"sm1": None, a : 0, "sm2": None},"test2","",None,True)
723     self.setExecutionOrder(["sm2","sm1"])
724    
725     # test messenger
726     m=Messenger()
727     m.run()
728     # ode1
729     o=Ode1()
730     o.dt=0.001
731     o.u=3.
732     o.run()
733     # ode1
734     o=Ode2()
735     o.dt=0.01
736     o.a=0.1
737     o.u=1.
738     o.run()
739     # and they are linked together:
740     o=Ode2()
741     m=Messenger()
742     om=Model(submodels=[o,m],debug=True)
743     om.dt=0.01
744     om.u=1.
745     m.message=Link(o)
746     om.run()
747     print om.showParameters()
748     1/0
749    
750     t=Test1()
751     t.tend=1.
752     t.dt=0.25
753     t.in1=1.
754     t.in2=3.
755     t.run()
756     # and a coupled problem:
757     t2=Test2()
758     t2.out1=Link(t)
759     Model([t,t2],debug=True).run()

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.26