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

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

Parent Directory | Revision Log | View Patch Patch

-revision 121 by jgs,
Fri May  6 04:26:16 2005 UTC
+revision 142 by jgs,
Mon Jul 25 05:28:20 2005 UTC
 Line 1
  # $Id$
- from types import StringType
+ from types import StringType,IntType,FloatType,BooleanType,ListType,DictType
+ from sys import stdout
+ import itertools
+ # import modellib  temporarily removed!!!
+ # import the 'set' module if it's not defined (python2.3/2.4 difference)
+ try:
+     set
+ except NameError:
+     from sets import Set as set
+ from xml.dom import minidom
+ def dataNode(document, tagName, data):
+     """
+     dataNodes are the building blocks of the xml documents constructed in
+     this module. document is the current xml document, tagName is the
+     associated xml tag, and data is the values in the tag.
+     """
+     t = document.createTextNode(str(data))
+     n = document.createElement(tagName)
+     n.appendChild(t)
+     return n
+ def esysDoc():
+     """
+     Global method for creating an instance of an EsysXML document.
+     """
+     doc = minidom.Document()
+     esys = doc.createElement('ESys')
+     doc.appendChild(esys)
+     return doc, esys
+ def all(seq):
+     for x in seq:
+         if not x:
+             return False
+     return True
+ LinkableObjectRegistry = {}
+ def registerLinkableObject(obj_id, o):
+     LinkableObjectRegistry[obj_id] = o
+ LinkRegistry = []
+ def registerLink(obj_id, l):
+     LinkRegistry.append((obj_id,l))
+ def parse(xml):
+     global LinkRegistry, LinkableObjectRegistry
+     LinkRegistry = []
+     LinkableObjectRegistry = {}
+     doc = minidom.parseString(xml)
+     sim = getComponent(doc.firstChild)
+     for obj_id, link in LinkRegistry:
+         link.target = LinkableObjectRegistry[obj_id]
+     return sim
+ def getComponent(doc):
+     for node in doc.childNodes:
+         if isinstance(node, minidom.Element):
+             if node.tagName == 'Simulation':
+                 if node.getAttribute("type") == 'Simulation':
+                     return Simulation.fromDom(node)
+                 elif node.getAttribute("type") == 'ExplicitSimulation':
+                     return ExplicitSimulation.fromDom(node)
+             if node.tagName == 'Model':
+                 model_type = node.getAttribute("type")
+                 model_subclasses = Model.__subclasses__()
+                 for model in model_subclasses:
+                     if model_type == model.__name__:
+                         return model.fromDom(node)
+             raise "Invalid simulation type, %r" % node.getAttribute("type")
+     raise ValueError("No Simulation Found")
  class Link:
-   """ """
+     """
-   def __init__(self,object,attribute=None):
+     a Link makes an attribute of an object callable:
-      self.__object=object
+           o.object()
-      self.setAttributeName(attribute)
+           o.a=8
+           l=Link(o,"a")
-   def setAttributeName(self,name):
+           assert l()==8
-      if not name==None:
+      """
-         if not hasattr(self.__object,name):
-            raise AttributeError("Link: object %s has no attribute %s."%(self.__object,name))
+     def __init__(self,target,attribute=None):
-      self.__attribute=name
+         """
+         creates a link to the object target. If attribute is given, the link is
-   def hasAttributeName(self):
+         establised to this attribute of the target.  Otherwise the attribute is
-       if self.__attribute==None:
+         undefined.
-          return False
+         """
-       else:
+         self.target = target
-          return True
+         self.attribute = None
+         self.setAttributeName(attribute)
-   def __str__(self):
-       if self.hasAttributeName():
+     def setAttributeName(self,attribute):
-           return "reference to %s of %s"%(self.__attribute,self.__object)
+         """
-       else:
+         set a new attribute name to be collected from the target object. The
-           return "reference to object %s"%self.__object
+         target object must have the attribute with name attribute.
+         """
-   def getValue(self,name=None):
+         if attribute and self.target and not hasattr(self.target, attribute):
-       if not self.hasAttributeName():
+             raise AttributeError("%s: target %s has no attribute %s."%(self, self.target, attribute))
-          out=getattr(self.__object,name)
+         self.attribute = attribute
-       else:
-          out=getattr(self.__object,self.__attribute)
+     def hasDefinedAttributeName(self):
-       if callable(out):
+         """
-           return out()
+         returns true if an attribute name is set
-       else:
+         """
-           return out
+         return self.attribute != None
+     def __repr__(self):
+         """
+         returns a string representation of the link
+         """
+         if self.hasDefinedAttributeName():
+             return "<Link to attribute %s of %s>" % (self.attribute, self.target)
+         else:
+             return "<Link to target %s>" % self.target
+     def __call__(self,name=None):
+         """
+         returns the value of the attribute of the target object. If the
+         atrribute is callable then the return value of the call is returned.
+         """
+         if name:
+             out=getattr(self.target, name)
+         else:
+             out=getattr(self.target, self.attribute)
+         if callable(out):
+             return out()
+         else:
+             return out
+     def toDom(self, document, node):
+         """
+         toDom method of Link. Creates a Link node and appends it to the current XML
+         document
+         """
+         link = document.createElement('Link')
+         link.appendChild(dataNode(document, 'Target', self.target.id))
+         # this use of id will not work for purposes of being able to retrieve the intended
+         # target from the xml later. I need a better unique identifier.
+         assert self.attribute, "You can't xmlify a Link without a target attribute"
+         link.appendChild(dataNode(document, 'Attribute', self.attribute))
+         node.appendChild(link)
+     def fromDom(cls, doc):
+         targetid = doc.getElementsByTagName("Target")[0].firstChild.nodeValue.strip()
+         attribute = doc.getElementsByTagName("Attribute")[0].firstChild.nodeValue.strip()
+         l = cls(None, attribute)
+         registerLink(targetid, l)
+         return l
+     fromDom = classmethod(fromDom)
+     def writeXML(self,ostream=stdout):
+         """
+         writes an XML representation of self to the output stream ostream.
+         If ostream is nor present the standart output stream is used.  If
+         esysheader==True the esys XML header is written
+         """
+         document, rootnode = esysDoc()
+         self.toDom(document, rootnode)
+         ostream.write(document.toprettyxml())
+ class LinkableObject(object):
+     """
+     An object that allows to link its attributes to attributes of other objects
+     via a Link object. For instance
+            p = LinkableObject()
+            p.x = Link(o,"name")
+            print p.x
+     links attribute x of p to the attribute name of object o.
+     p.x will contain the current value of attribute name of object o.
+     If the value of getattr(o, "name") is callable, p.x will rturn the return
+     value of the call.
+     """
- class Model:
+     number_sequence = itertools.count(100)
-    """ the Model class provides a framework to run a time-dependent simulation. A Model has a set of parameter which
-        may be fixed or altered by the Model itself or other Models over time.
+     def __init__(self, debug=False):
+         """ initializes LinkableObject so that we can operate on Links """
+         self.debug = debug
+         self.__linked_attributes={}
+         self.id = self.number_sequence.next()
+     def trace(self, msg):
+         """ If debugging is on, print the message, otherwise do nothing
+         """
+         if self.debug:
+             print msg
+     def __getattr__(self,name):
+         """returns the value of attribute name. If the value is a Link object the
+         object is called and the return value is returned."""
+         out = self.getAttributeObject(name)
+         if isinstance(out,Link):
+             return out()
+         else:
+             return out
+     def getAttributeObject(self,name):
+         """return the object stored for attribute name."""
+         if self.__dict__.has_key(name):
+             return self.__dict__[name]
+         if self.__linked_attributes.has_key(name):
+             return self.__linked_attributes[name]
+         raise AttributeError,"No attribute %s."%name
+     def __setattr__(self,name,value):
+         """sets the value for attribute name. If value is a Link the target
+         attribute is set to name if no attribute has been specified."""
+         if self.__dict__.has_key(name):
+             del self.__dict__[name]
+         if isinstance(value,Link):
+             if not value.hasDefinedAttributeName():
+                 value.setAttributeName(name)
+             self.__linked_attributes[name] = value
+             self.trace("DEBUG: %s: attribute %s is now linked by %s."%(self,name,value))
+         else:
+             self.__dict__[name] = value
+     def __delattr__(self,name):
+         """removes the attribute name."""
+         if self.__linked_attributes.has_key[name]:
+             del self.__linked_attributes[name]
+         elif self.__dict__.has_key(name):
+             del self.__dict__[name]
+         else:
+             raise AttributeError,"No attribute %s."%name
+ class SimulationFrame(LinkableObject):
+     """A SimulationFrame objects represents a processess marching over time
+     until a finalizing condition is fullfilled.  At each time step an iterative
+     process can be performed and the time step size can be controlled
+     """
+     UNDEF_DT=1.e300
+     MAX_TIME_STEP_REDUCTION=20
+     MAX_ITER_STEPS=50
+     def __init__(self,**kwargs):
+         """
+         Initialises a simulation
+         Just calls the parent constructor.
+         """
+         LinkableObject.__init__(self,**kwargs)
+     def doInitialization(self,t):
+         """initializes the time stepping scheme. This function may be
+         overwritten."""
+         pass
+     def getSafeTimeStepSize(self,dt):
+         """returns a time step size which can savely be used. This function may
+         be overwritten."""
+         return self.UNDEF_DT
+     def finalize(self):
+         """returns True if the time stepping is finalized. This function may be
+         overwritten."""
+         return True
+     def doFinalization(self):
+         """finalizes the time stepping.  This function may be overwritten."""
+         pass
+     def doIterationInitialization(self,dt):
+         """initializes the iteration at time step t. This function may be
+         overwritten. (only called if doStep is not overwritten)"""
+         pass
+     def doIterationStep(self,dt):
+         """executes the iteration step. This function may be overwritten. (only
+         called if doStep is not overwritten)"""
+         pass
+     def terminate(self):
+         """returns True if iteration on a time step is terminated. (only called
+         if doStep is not overwritten)"""
+         return True
+     def doIterationFinalization(self,dt):
+         """finalalizes the iteration process. (only called if doStep is not
+         overwritten)"""
+         pass
+     def run(self,check_point=None):
+         """run the simulation by performing essentially
+             self.doInitialization()
+             while not self.finalize():
+                dt=self.getSafeTimeStepSize()
+                self.doStep(dt)
+                if n%check_point==0: self.writeXML()
+             self.doFinalization()
+         """
+         self.__tn=0.
+         self.__n=0
+         self.__dt=None
+         self.doInitialization(self.__tn)
+         while not self.finalize():
+             self.__n+=1
+             self.__dt=self.getSafeTimeStepSize(self.__dt)
+             if self.__dt==None: self.__dt=self.UNDEF_DT
+             if not self.__dt>0:
+                  raise NonPositiveStepSizeError("non-positive step size in step %d",self.__n)
+             self.trace("%s: %d. time step %e (step size %e.)" %
+                           (self,self.__n,self.__tn+self.__dt,self.__dt))
+             endoftimestep=False
+             failcounter=0
+             while not endoftimestep:
+                 endoftimestep=True
+                 try:
+                     self.doStep(self.__dt)
+                 except FailedTimeStepError:
+                     self.__dt=self.getSafeTimeStepSize(self.__dt)
+                     if self.__dt==None: self.__dt=self.UNDEF_DT
+                     endoftimestep=False
+                     self.trace("%s: time step is repeated with new step size %e."%(self,self.__dt))
+                 except IterationDivergenceError:
+                     self.__dt*=0.5
+                     endoftimestep=False
+                     failcounter+=1
+                     if failcounter>self.MAX_TIME_STEP_REDUCTION:
+                         raise IterationBreakDownError("reduction of time step to achieve convergence failed.")
+                     self.trace("%s: iteration failes. time step is repeated with new step size %e."
+                         % (self,self.__dt))
+             self.__tn+=self.__dt
+             if not check_point==None:
+                 if self.__n%check_point==0:
+                     self.trace("%s: check point is created."%self)
+                     self.writeXML()
+         self.doFinalization()
+     def writeXML(self):
+         raise RuntimeError, "Not implemented"
+     def doStep(self,dt):
+         """executes a time step by iteration. This function may be overwritten.
+            basicly it performs :
+             self.doIterationInitialization(dt)
+             while not self.terminate(): self.doIterationStep(dt)
+             self.doIterationFinalization(dt)
+         """
+         self.doIterationInitialization(dt)
+         self.__iter=0
+         while not self.terminate():
+             self.trace("%s: iteration step %d"%(self,self.__iter))
+             self.doIterationStep(dt)
+             self.__iter+=1
+             if self.__iter>self.MAX_ITER_STEPS:
+                 raise IterationDivergenceError("%s: divergence in step %d"%(self,self.__iter))
+         self.doIterationFinalization(dt)
+ class Simulation(SimulationFrame):
+     """A Simulation object is comprised by SimulationFrame(s) called subsimulations."""
+     def __init__(self, subsimulations=[], **kwargs):
+         """initiates a simulation from a list of subsimulations. """
+         SimulationFrame.__init__(self, **kwargs)
+         self.__subsimulations=[]
+         for i in range(len(subsimulations)):
+             self[i] = subsimulations[i]
+     def iterSubsimulations(self):
+         """returns an iterator over the subsimulations"""
+         return self.__subsimulations
+     def __getitem__(self,i):
+         """returns the i-th subsimulation"""
+         return self.__subsimulations[i]
+     def __setitem__(self,i,value):
+         """sets the i-th subsimulation"""
+         if not isinstance(value,SimulationFrame):
+             raise ValueError("assigned value is not a Simulation")
+         for j in range(max(i-len(self.__subsimulations)+1,0)): self.__subsimulations.append(None)
+         self.__subsimulations[i]=value
+     def __len__(self):
+         """returns the number of subsimulations"""
+         return len(self.__subsimulations)
+     def toDom(self, document, node):
+         """ toDom method of Simulation class """
+         simulation = document.createElement('Simulation')
+         simulation.setAttribute('type', self.__class__.__name__)
+         for rank, sim in enumerate(self.iterSubsimulations()):
+             component = document.createElement('Component')
+             component.setAttribute('rank', str(rank))
+             sim.toDom(document, component)
+             simulation.appendChild(component)
+         node.appendChild(simulation)
+     def writeXML(self,ostream=stdout):
+         """writes the object as an XML object into an output stream"""
+         document, rootnode = esysDoc()
+         self.toDom(document, rootnode)
+         ostream.write(document.toprettyxml())
+     def getSafeTimeStepSize(self,dt):
+         """returns a time step size which can safely be used by all subsimulations"""
+         out=self.UNDEF_DT
+         for o in self.iterSubsimulations():
+             dt_new = o.getSafeTimeStepSize(dt)
+             if dt_new != None:
+                 out = min(out,dt_new)
+         return out
+     def doInitialization(self,dt):
+         """initializes all subsimulations """
+         for o in self.iterSubsimulations():
+             o.doInitialization(dt)
+     def finalize(self):
+         """returns True if all subsimulations are finalized"""
+         return all([o.finalize() for o in self.iterSubsimulations()])
+     def doFinalization(self):
+         """finalalizes the time stepping for all subsimulations."""
+         for i in self.iterSubsimulations(): i.doFinalization()
+     def doIterationInitialization(self,dt):
+         """initializes the iteration at time t for all subsimulations."""
+         self.__iter=0
+         self.trace("%s: iteration starts"%self)
+         for o in self.iterSubsimulations():
+             o.doIterationInitialization(dt)
+     def terminate(self):
+         """returns True if all iterations for all subsimulations are terminated."""
+         return all([o.terminate() for o in self.iterSubsimulations()])
+     def doIterationFinalization(self,dt):
+         """finalalizes the iteration process for each of the subsimulations."""
+         for o in self.iterSubsimulations():
+             o.doIterationFinalization(dt)
+         self.trace("%s: iteration finalized after %s steps"%(self,self.__iter+1))
+     def doIterationStep(self,dt):
+         """executes the iteration step at time step for each subsimulation"""
+         self.__iter+=1
+         self.trace("%s: iteration step %d"%(self,self.__iter))
+         for o in self.iterSubsimulations():
+             o.doIterationStep(dt)
+     def fromDom(cls, doc):
+         """
+         Needs to be filled out.
+         """
+         sims = []
+         for node in doc.childNodes:
+             if isinstance(node, minidom.Text):
+                 continue
+             sims.append(getComponent(node))
+         return cls(sims)
+     fromDom = classmethod(fromDom)
+ class ExplicitSimulation(Simulation):
+     """This is a modified form of the Simulation class. In fact it overwrites
+     the doStep method by executing the doStep method of all subsimulations
+     rather then iterating over all subsimulations."""
+     def doStep(self,dt):
+         """executes the time step for all subsimulation"""
+         for i in self.iterSubsimulations():
+             i.doStep(dt)
+ class _ParameterIterator:
+     def __init__(self,parameterset):
+         self.__set=parameterset
+         self.__iter=iter(parameterset.parameters)
+     def next(self):
+         o=self.__iter.next()
+         return (o,self.__set.getAttributeObject(o))
+     def __iter__(self):
+         return self
+ class ParameterSet(LinkableObject):
+     """a class which allows to emphazise attributes to be written and read to XML
+        Leaves of  an ESySParameters objects can be
+             a real number
+             a integer number
+             a string
+             a boolean value
+             a ParameterSet object
+             a Simulation object
+             a Model object
+             any other object (not considered by writeESySXML and writeXML)
+            Example how to create an ESySParameters object:
+                  p11=ParameterSet(gamma1=1.,gamma2=2.,gamma3=3.)
+                  p1=ParameterSet(dim=2,tol_v=0.001,output_file="/tmp/u.%3.3d.dx",runFlag=True,parm11=p11)
+                  parm=ParameterSet(parm1=p1,parm2=ParameterSet(alpha=Link(p11,"gamma1")))
+            This can be accessed as
+                  parm.parm1.gamma=0.
+                  parm.parm1.dim=2
+                  parm.parm1.tol_v=0.001
+                  parm.parm1.output_file="/tmp/u.%3.3d.dx"
+                  parm.parm1.runFlag=True
+                  parm.parm1.parm11.gamma1=1.
+                  parm.parm1.parm11.gamma2=2.
+                  parm.parm1.parm11.gamma3=3.
+                  parm.parm2.alpha=1. (value of parm.parm1.parm11.gamma1)
+     """
+     def __init__(self, parameters=[], **kwargs):
+         """creates a ParameterSet with parameters parameters"""
+         LinkableObject.__init__(self, **kwargs)
+         self.parameters = set()
+         self.declareParameters(parameters)
+     def declareParameter(self,**parameters):
+         """declares a new parameter(s) and its (their) inital value."""
+         self.declareParameters(parameters)
+     def declareParameters(self,parameters):
+         """declares a set of parameters. parameters can be a list, a dictonary or a ParameterSet."""
+         if isinstance(parameters,ListType):
+             parameters = zip(parameters, itertools.repeat(None))
+         if isinstance(parameters,DictType):
+             parameters = parameters.iteritems()
+         for prm, value in parameters:
+             setattr(self,prm,value)
+             self.parameters.add(prm)
+             self.trace("%s: parameter %s has been declared."%(self,prm))
+     def releaseParameters(self,name):
+         """removes parameter name from the paramameters"""
+         if self.isParameter(name):
+             self.parameters.remove(name)
+             self.debug("%s: parameter %s has been removed."%(self, name))
+     def __iter__(self):
+         """creates an iterator over the parameter and their values"""
+         return _ParameterIterator(self)
+     def showParameters(self):
+         """returns a descrition of the parameters"""
+         out="{"
+         notfirst=False
+         for i,v in self:
+             if notfirst: out=out+","
+             notfirst=True
+             if isinstance(v,ParameterSet):
+                 out="%s\"%s\" : %s"%(out,i,v.showParameters())
+             else:
+                 out="%s\"%s\" : %s"%(out,i,v)
+         return out+"}"
+     def __delattr__(self,name):
+         """removes the attribute name."""
+         LinkableObject.__delattr__(self,name)
+         try:
+             self.releaseParameter(name)
+         except:
+             pass
+     def toDom(self, document, node):
+         """ toDom method of ParameterSet class """
+         pset = document.createElement('ParameterSet')
+         node.appendChild(pset)
+         self._parametersToDom(document, pset)
+     def _parametersToDom(self, document, node):
+         node.setAttribute ('id', str(self.id))
+         for name,value in self:
+             param = document.createElement('Parameter')
+             param.setAttribute('type', value.__class__.__name__)
+             param.appendChild(dataNode(document, 'Name', name))
+             val = document.createElement('Value')
+             if isinstance(value,ParameterSet):
+                 value.toDom(document, val)
+                 param.appendChild(val)
+             elif isinstance(value, Link):
+                 value.toDom(document, val)
+                 param.appendChild(val)
+             elif isinstance(value,StringType):
+                 param.appendChild(dataNode(document, 'Value', value))
+             else:
+                 param.appendChild(dataNode(document, 'Value', str(value)))
+             node.appendChild(param)
+     def fromDom(cls, doc):
+         # Define a host of helper functions to assist us.
+         def _children(node):
+             """
+             Remove the empty nodes from the children of this node
+             """
+             return [x for x in node.childNodes
+                     if not isinstance(x, minidom.Text) or x.nodeValue.strip()]
+         def _floatfromValue(doc):
+             return float(doc.nodeValue.strip())
+         def _stringfromValue(doc):
+             return str(doc.nodeValue.strip())
+         def _intfromValue(doc):
+             return int(doc.nodeValue.strip())
+         def _boolfromValue(doc):
+             return bool(doc.nodeValue.strip())
+         # Mapping from text types in the xml to methods used to process trees of that type
+         ptypemap = {"Simulation": Simulation.fromDom,
+                     "Model":Model.fromDom,
+                     "ParameterSet":ParameterSet.fromDom,
+                     "Link":Link.fromDom,
+                     "float":_floatfromValue,
+                     "int":_intfromValue,
+                     "str":_stringfromValue,
+                     "bool":_boolfromValue
+                     }
+         parameters = {}
+         for node in _children(doc):
+             ptype = node.getAttribute("type")
+             pname = pvalue = None
+             for childnode in _children(node):
+                 if childnode.tagName == "Name":
+                     pname = childnode.firstChild.nodeValue.strip()
+                 if childnode.tagName == "Value":
+                     nodes = _children(childnode)
+                     pvalue = ptypemap[ptype](nodes[0])
+             parameters[pname] = pvalue
+         # Create the instance of ParameterSet
+         o = cls()
+         o.declareParameters(parameters)
+         registerLinkableObject(doc.getAttribute("id"), o)
+         return o
+     fromDom = classmethod(fromDom)
+     def writeXML(self,ostream=stdout):
+         """writes the object as an XML object into an output stream"""
+         # ParameterSet(d) with d[Name]=Value
+         document, node = esysDoc()
+         self.toDom(document, node)
+         ostream.write(document.toprettyxml())
+ class Model(ParameterSet,SimulationFrame):
+     """a Model is a SimulationFrame which is also a ParameterSet."""
+     def __init__(self,parameters=[],**kwargs):
+         """creates a model"""
+         ParameterSet.__init__(self, parameters=parameters)
+         SimulationFrame.__init__(self,**kwargs)
+     def toDom(self, document, node):
+         """ toDom method of Model class """
+         pset = document.createElement('Model')
+         pset.setAttribute('type', self.__class__.__name__)
+         node.appendChild(pset)
+         self._parametersToDom(document, pset)
+ class IterationDivergenceError(Exception):
+     """excpetion which should be thrown if there is no convergence of the iteration process at a time step but there is a chance taht a smaller step could help
+        to reach convergence."""
+     pass
+ class IterationBreakDownError(Exception):
+     """excpetion which should be thrown if there is no conevregence and there is no chance that a time step reduction would help"""
+     pass
+ class FailedTimeStepError(Exception):
+     """excpetion which should be thrown if the time step fails because of a step size that have been choosen to be to large"""
+     pass
+ class NonPositiveStepSizeError(Exception):
+     """excpetion which is thrown if the step size is not positive"""
+     pass
+ #
+ #   ignore this text:
+ #
+ """
+ the Model class provides a framework to run a time-dependent simulation. A
+ Model has a set of parameter which may be fixed or altered by the Model itself
+ or other Models over time.
         The parameters of a models are declared at instantion, e.g.
             m=Model({"message" : "none" })
-        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:
+        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:
          class Messenger(Model):
              def __init__(self):
-Line 73 
 class Model:
+Line 780 
 class Model:
            m=Messenger()
            m.run()
         The run methods marches through time. It first calls the
-        doInitialization() method of the Model to set up the process. In each time step the doStep() method is called
+        doInitialization() method of the Model to set up the process. In each
-        to get from the current to the next time step. The step size is defined by calling the getSafeTimeStepSize() method.
+        time step the doStep() method is called to get from the current to the
-        The time integration process is terminated when the finalize() methods return true. Final the doFinalization() method
+        next time step. The step size is defined by calling the
-        is called to finalize the process. To implement a particular model a subclass
+        getSafeTimeStepSize() method.  the time integration process is
-        of the Model class is defined. The subclass overwrites the default methods of Model.
+        terminated when the finalize() methods return true. Final the
+        doFinalization() method is called to finalize the process. To implement
+        a particular model a subclass of the Model class is defined. The
+        subclass overwrites the default methods of Model.
-        The following class defines a messenger printing in the doStep method what ever the current value of its parameter message is:
+        The following class defines a messenger printing in the doStep method
+        what ever the current value of its parameter message is:
         class Messenger(Model):
              def __init__(self):
-Line 95 
 class Model:
+Line 806 
 class Model:
              def doFinalization(self):
                 print "I have no more to say!"
-        If a instance of the Messenger class is run, it will print the initialization and finalization message only.
+        If a instance of the Messenger class is run, it will print the
-        This is because the default method for finalize() does always returns True and therefore the transition is
+        initialization and finalization message only.  This is because the
-        terminated startcht away.
+        default method for finalize() does always returns True and therefore the
+        transition is terminated startcht away.
         Following example for solving the ODE using a forward euler scheme:
-Line 126 
 class Model:
+Line 838 
 class Model:
           def finalize(self):
               return self._tn>=self.tend
-        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. `
+        In some cases at a given time step an iteration process has to be
-        In this case the doStep() method is replaced by a sequance of methods which implements this iterative process.
+        performed to get the state of the Model for the next time step. ` In
-        The method then will control the iteration process by initializing the iteration through calling the
+        this case the doStep() method is replaced by a sequance of methods which
-        doIterationInitialization() method. The iteration is preformed by calling the doIterationStep() method until
+        implements this iterative process.  The method then will control the
-        the terminate() method returns True. The doIterationFinalization() method is called to end the iteration.
+        iteration process by initializing the iteration through calling the
-        For a particular model these methods have to overwritten by a suitable subclass without touching the doStep() method.
+        doIterationInitialization() method. The iteration is preformed by
+        calling the doIterationStep() method until the terminate() method
+        returns True. The doIterationFinalization() method is called to end the
+        iteration.
+        For a particular model these methods have to overwritten by a suitable
+        subclass without touching the doStep() method.
-        following example is a modification of the example above. Here an implicit euler scheme is used. in each time step the problem
+        following example is a modification of the example above. Here an
+        implicit euler scheme is used. in each time step the problem
 = u_{n+1}-u_{n}+a*dt*u_{n+1}**2
-Line 171 
 class Model:
+Line 889 
 class Model:
         def finalize(self):
              return self.__tn>self.tend
-        A model can be composed from submodels. Submodels are treated as model parameters. If a model parameter is set or a value of
+        A model can be composed from subsimulations. Subsimulations are treated
-        a model parameter is requested, the model will search for this parameter its submodels in the case the model does not have this
+        as model parameters. If a model parameter is set or a value of a model
-        parameter itself. The order in which the submodels are searched is critical. By default a Model initializes all its submodels,
+        parameter is requested, the model will search for this parameter its
-        is finalized when all its submodels are finalized and finalizes all its submodels. In the case an iterative process is applied
+        subsimulations in the case the model does not have this parameter
-        on a particular time step the iteration is initialized for all submodels, then the iteration step is performed for each submodel
+        itself. The order in which the subsimulations are searched is critical.
-        until all submodels indicate termination. Then the iteration is finalized for all submodels. Finally teh doStop() method for all
+        By default a Model initializes all its subsimulations, is finalized when
-        submethods is called.
+        all its subsimulations are finalized and finalizes all its
+        subsimulations. In the case an iterative process is applied on a
+        particular time step the iteration is initialized for all
+        subsimulations, then the iteration step is performed for each
+        subsimulation until all subsimulations indicate termination. Then the
+        iteration is finalized for all subsimulations. Finally teh doStop()
+        method for all submethods is called.
         Here we are creating a model which groups ab instantiation of the Ode2 and the Messenger Model
         o=Ode2()
         m=Messenger()
-        om=Model(submodels=[o,m],debug=True)
+        om=Model(subsimulations=[o,m],debug=True)
         om.dt=0.01
         om.u=1.
         m.message="it's me!"
         om.run()
-        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
+        Notice that dt and u are parameters of class Ode2 and message is a
-        automatically hand the assignment of new values down to the submodel. om.run() starts this combined model where now the soStep() method
+        parameter of the Messenger class. The Model formed from these models
-        of the Messenger object printing the value of its parameter message together with a time stamp is executed in each time step introduced
+        automatically hand the assignment of new values down to the
-        by the Ode2 model.
+        subsimulation. om.run() starts this combined model where now the
+        soStep() method of the Messenger object printing the value of its
+        parameter message together with a time stamp is executed in each time
+        step introduced by the Ode2 model.
-        A parameter of a Model can be linked to an attribute of onother object, typically an parameter of another Model object.
+        A parameter of a Model can be linked to an attribute of onother object,
+        typically an parameter of another Model object.
-        which is comprised by a set of submodels.
+        which is comprised by a set of subsimulations.
         The simulation is run through its run method which in the simplest case has the form:
            s=Model()
            s.run()
-        The run has an initializion and finalization phase. The latter is called if all submodels are to be finalized. The
+        The run has an initializion and finalization phase. The latter is called
-        simulation is processing in time through calling the stepForward methods which updates the observables of each submodel.
+        if all subsimulations are to be finalized. The simulation is processing
-        A time steps size which is save for all submodel is choosen.
+        in time through calling the stepForward methods which updates the
+        observables of each subsimulation.  A time steps size which is save for
-        At given time step an iterative process may be performed to make sure that all observables are consistent across all submodels.
+        all subsimulation is choosen.
-        In this case, similar the time dependence, an initialization and finalization of the iteration is performed.
+        At given time step an iterative process may be performed to make sure
-        A Model has input and output parameters where each input parameter can be constant, time dependent or may depend on an
+        that all observables are consistent across all subsimulations.  In this
-        output parameter of another model or the model itself. To create a parameter name of a model and to
+        case, similar the time dependence, an initialization and finalization of
-        assign a value to it one can use the statement
+        the iteration is performed.
+        A Model has input and output parameters where each input parameter can
+        be constant, time dependent or may depend on an output parameter of
+        another model or the model itself. To create a parameter name of a model
+        and to assign a value to it one can use the statement
             model.name=object
-Line 221 
 class Model:
+Line 954 
 class Model:
                 value=model.name
-        If the object that has been assigned to the paramter/attribute name has the attribute/parameter name isself the current value of this
+        If the object that has been assigned to the paramter/attribute name has
-        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
+        the attribute/parameter name isself the current value of this attribute
-        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
+        of the object is returned (e.g. for model.name=object where object has
+        an attribute name, the statement value=model.name whould assign 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
             model.setParameter(name,object,name_for_object)
-        links the parameter name of model with the parameter name_for_object of object.
+        links the parameter name of model with the parameter name_for_object of
+        object.
-        The run method initiates checkpointing (it is not clear how to do this yet)
+        The run method initiates checkpointing (it is not clear how to do this
+        yet)
     =====
     """
-    # step size used in case of an undefined value for the step size
-    UNDEF_DT=1.e300
-    def __init__(self,submodels=[],parameters={},name="model",description="none",check_pointing=None,debug=False):
-       """initiates a model from a list of submodels. """
-       self.setDebug(debug)
-       self.__check_pointing=check_pointing
-       self.__parameters={}
-       self.setName(name)
-       self.setDescription(description)
-       self.declareParameter(**parameters)
-       # get the models defined in parameters:
-       self.__submodels=[]
-       # submodels==None means no submodels used:
-       if submodels==None:
-          pass
-       # no submodel list given means all submodels are used as defined by the parameters dictionary:
-       elif len(submodels)==0:
-             for i in parameters.keys():
-                 if isinstance(parameters[i],Model): self.__submodels.append(i)
-       # submodel list of strings and Models is given, submodels defines the order in which the
-       # submodels are processed. if new models are found in the list they are added to the parameter dictionary.
-       else:
-          c=0
-          for i in submodels:
-             if isinstance(i,StringType):
-               m=self.getParameter(i)
-               if not isinstance(m,Model):
-                  raise ValueError,"submodel %s is not a model."%i
-             else:
-                if not isinstance(i,Model):
-                  raise ValueError,"submodel list does contain item which is not a Model class object."
-                m=i
-                i="__submodel%d__"%c
-                self.declareParameter(**{i : m})
-                c+=1
-             self.__submodels.append(i)
-             if self.debug(): print "%s: model %s is added as parameter %s."%(self,m,i)
-       if len(self.__submodels)>0 and self.debug(): print "%s: model ordering is %s"%(self,self.__submodels)
-    def setSubmodelOrder(submodels=[]):
-       """sets a new ordering for submodels"""
-    #
-    # some basic fuctions:
-    #
-    def debugOn(self):
-       """sets debugging to on"""
-       self.__debug=True
-    def debugOff(self):
-       """sets debugging to off"""
-       self.__debug=False
-    def debug(self):
-       """returns True if debug mode is set to on"""
-       return self.__debug
-    def setDebug(self,flag=False):
-       """sets debugging to flag"""
-       if flag:
-          self.debugOn()
-       else:
-          self.debugOff()
-    def setDebug(self,flag=False):
-       """sets debugging to flag"""
-       if flag:
-          self.debugOn()
-       else:
-          self.debugOff()
-    # name and description handling
-    def __str__(self):
-        """returns the name of the model"""
-        return self.getName()
-    def getName(self):
-        """returns the name of the model"""
-        return self.__name
-    def getFullName(self):
-        """returns the full name of the model including all the names of the submodels"""
-        out=str(self)+"("
-        notfirst=False
-        for i in self.__submodels:
-             if notfirst: out=out+","
-             out=out+i.getFullName()
-             notfirst=True
-        return out+")"
-    def setName(self,name):
-        """sets the name of the model"""
-        self.__name=name
-    def setDescription(self,description="none"):
-        """sets new description"""
-        self.__description=description
-        if self.debug(): print "%s: description is set to %s."%(self,description)
-    def getDescription(self):
-        """returns the description of the model"""
-        return self.__description
-    #
-    #    parameter/attribute handling:
-    #
-    def declareParameter(self,**parameters):
-       """declares a new parameter and its inital value."""
-       for prm in parameters.keys():
-          if prm in self.__dict__.keys():
-              raise ValueError,"object attribute %s of %s cannot be used as a model parameter."%(prm,self)
-          self.__parameters[prm]=parameters[prm]
-          if self.debug(): print "%s: parameter %s has been declared."%(self,prm)
-    def showParameters(self):
-       """returns a descrition of the parameters"""
-       out=""
-       notfirst=False
-       for i in self.__parameters:
-           if notfirst: out=out+","
-           notfirst=True
-           out="%s%s=%s"%(out,i,self.__parameters[i])
-       return out
-    def deleteParameter(self,name):
-       """removes parameter name from the model"""
-       raise IllegalParameterError("Cannot delete parameter %s."%name)
-    def getParameter(self,name):
-       """returns the value of parameter name. If the parameter is not declared in self, the submodels are searched.
-          if the parameter is a Link, the current value of the obejective is returned."""
-       if self.__parameters.has_key(name):
-           if isinstance(self.__parameters[name],Link):
-              out=self.__parameters[name].getValue(name)
-           else:
-              out=self.__parameters[name]
-       else:
-           out=None
-           for i in self.__submodels:
-              try:
-                 out=self.__parameters[i].getParameter(name)
-              except IllegalParameterError:
-                 pass
-           if out==None: raise IllegalParameterError("Cannot find parameter %s."%name)
-       return out
-    def setParameter(self,**parameters):
-       """sets parameter name to value. If the initial value for the parameter is a Model, the new value has to be a Model."""
-       for name in parameters.keys():
-          if self.__parameters.has_key(name):
-             if not isinstance(parameters[name],Model) and isinstance(self.__parameters[name],Model):
-                 raise ValueError,"%s: parameter %s can assigned to a Model object only."%(self,name)
-             if isinstance(parameters[name],Model) and not isinstance(self.__parameters[name],Model):
-                 raise ValueError,"%s: parameter %s is not declared as a Model."%(self,name)
-             self.__parameters[name]=parameters[name]
-             if isinstance(self.__parameters[name],Link):
-                  if not self.__parameters[name].hasAttributeName(): self.__parameters[name].setAttributeName(name)
-             if self.debug(): print "%s: parameter %s has now value %s"%(self,name,self.__parameters[name])
-          else:
-             set=False
-             for i in self.__submodels:
-                 try:
-                    self.__parameters[i].setParameter(**{name : parameters[name]})
-                    set=True
-                 except IllegalParameterError:
-                     pass
-             if not set: raise IllegalParameterError("%s: Attempt to set undeclared parameter %s."%(self,name))
-    def hasParameter(self,name):
-       """returns True if self or one of the submodels has parameter name"""
-       if self.__parameters.has_key(name):
-          out=True
-       else:
-          out=False
-          for i in self.__submodels: out= out or self.__parameters[i].hasParameter(name)
-       return out
-    def checkParameter(self,name):
-       """checks if self has the parameter name. Otherewise ParameterError is thrown."""
-       if not self.hasParameter(name):
-            raise ParameterError("%s has no parameter %s."%(str(self),name))
-    def __getattr__(self,name):
-       """returns the value for attribute name. If name is in the Link list, the corresponding attribute is returned."""
-       if self.__dict__.has_key(name):
-          return self.__dict__[name]
-       elif self.__dict__.has_key("_Model__parameters") and self.__dict__.has_key("_Model__submodels"):
-          return self.getParameter(name)
-       else:
-          raise AttributeError,"No attribute %s."%name
-    def __setattr__(self,name,value):
-       """returns the value for attribute name."""
-       if self.__dict__.has_key("_Model__parameters") and self.__dict__.has_key("_Model__submodels"):
-          if self.hasParameter(name):
-             self.setParameter(**{ name : value })
-          else:
-             self.__dict__[name]=value
-       else:
-          self.__dict__[name]=value
-    def __delattr__(self,name):
-       """removes the attribute name."""
-       if self.__dict__.has_key(name):
-          del self.__dict__[name]
-       elif self.__dict__.has_key("_Model__parameters"):
-          self.deleteParameter(name)
-       else:
-          raise AttributeError,"No attribute %s."%name
-    #
-    #    submodel handeling:
-    #
-    def doInitializationOfSubmodels(self):
-       """initializes the time stepping for all submodels."""
-       for i in self.__submodels: self.getParameter(i).doInitialization()
-    def getSafeTimeStepSizeFromSubmodels(self):
-       """returns a time step size which can savely be used by all submodels. To avoid a big increase in the step size,
-          the new step size is restricted to the double of the precious step size."""
-       out=None
-       for i in self.__submodels:
-           dt=self.getParameter(i).getSafeTimeStepSize()
-           if not dt==None:
-               if out==None:
-                  out=dt
-               else:
-                  out=min(out,dt)
-       return out
-    def doStepOfSubmodels(self,t):
-       """executes the time step for each submodel"""
-       for i in self.__submodels: self.getParameter(i).doStep(t)
-    def finalizeAllSubmodels(self):
-       """returns True if all submodels can be finalized"""
-       out=True
-       for i in self.__submodels: out = out and self.getParameter(i).finalize()
-       return out
-    def doFinalizationOfSubmodels(self):
-       """finalalizes the time stepping for each of the submodels."""
-       for i in self.__submodels: self.getParameter(i).doFinalization()
-    def doIterationInitializationOfSubmodels(self,t):
-       """initializes the iteration for each of the submodels."""
-       for i in self.__submodels: self.getParameter(i).doIterationInitialization(t)
-    def doIterationStepOfSubmodels(self):
-       """executes the iteration step at time step for each submodel"""
-       for i in self.__submodels: self.getParameter(i).doIterationStep()
-    def terminateAllSubmodels(self):
-       """returns True if all iterations for all submodels are terminated."""
-       out=True
-       for i in self.__submodels: out = out and self.getParameter(i).terminate()
-       return out
-    def doIterationFinalizationOfSubmodels(self):
-       """finalalizes the iteration process for each of the submodels."""
-       for i in self.__submodels: self.getParameter(i).doIterationFinalization()
-    def checkPointSubmodels(self):
-       """performs check pointing for each submodel"""
-       for i in self.__submodels: self.getParameter(i).checkPoint()
-    #
-    #   these methods control the time stepping
-    #
-    def doInitialization(self):
-       """initializes the time stepping"""
-       self.doInitializationOfSubmodels()
-    def getSafeTimeStepSize(self):
-       """returns a time step size which can savely be used"""
-       return self.getSafeTimeStepSizeFromSubmodels()
-    def doStep(self,t):
-       """executes the time step by first iterating over time step t and then step forward"""
-       # run iteration on simulation until terminated:
-       self.doIterationInitialization(t)
-       while not self.terminate(): self.doIterationStep()
-       self.doIterationFinalization()
-       self.doStepOfSubmodels(t)
-    def finalize(self):
-       """returns True if all submodels are to be finalized"""
-       return self.finalizeAllSubmodels()
-    def doFinalization(self):
-       """finalizes the time stepping."""
-       self.doFinalizationOfSubmodels()
-    #
-    #   methods deal with iterations:
-    #
-    def doIterationInitialization(self,t):
-       """initializes the iteration on a time step"""
-       self.__iter=0
-       if self.debug(): print "%s: iteration starts"%self
-       self.doIterationInitializationOfSubmodels(t)
-    def doIterationStep(self):
-       """executes the iteration step"""
-       self.__iter+=1
-       if self.debug(): print "%s: iteration step %d"%(self,self.__iter)
-       try:
-          self.doIterationStepOfSubmodels()
-       except IterationDivergenceError,e:
-          raise IterationDivergenceError("divergence at time step %s in iteration step %s by reason: \n%s."%(self.__n,self.__iter,e.value))
-    def terminate(self):
-       """returns True if time steping is terminated"""
-       return self.terminateAllSubmodels()
-    def doIterationFinalization(self):
-       """finalalizes the iteration process."""
-       self.doIterationFinalizationOfSubmodels()
-       if self.debug(): print "%s: iteration finalized after %s step"%(self,self.__iter)
-    #
-    #   sum other method:
-    #
-    def checkPoint(self):
-       """performs check pointing for each submodel"""
-       if not self.__check_pointing==None:
-          if self.__n%self.__check_pointing==0: self.checkPointsSubmodels()
-    def run(self):
-       """After check_pointing time steps the model will start to create checkpoint files for each of the submodels"""
-       self.__tn=0.
-       self.__n=0
-       self.__dt=None
-       self.doInitialization()
-       while not self.finalize():
-          self.__n+=1
-          self.__dt=self.getSafeTimeStepSize()
-          if self.__dt==None: self.__dt=self.UNDEF_DT
-          if self.debug(): print "%s: %d. time step %e (step size %e.)"%(self,self.__n,self.__tn+self.__dt,self.__dt)
-          endoftimestep=False
-          while not endoftimestep:
-               endoftimestep=True
-               try:
-                  self.doStep(self.__tn+self.__dt)
-               except FailedTimeStepError:
-                  self.__dt=self.getSafeTimeStepSize()
-                  if self.__dt==None: self.__dt=self.UNDEF_DT
-                  endoftimestep=False
-                  if self.debug(): print "%s: time step is repeated with new step size %e."%(self,self.__dt)
-               except IterationDivergenceError:
-                  self.__dt*=0.5
-                  endoftimestep=False
-                  if self.debug(): print "%s: iteration failes. time step is repeated with new step size %e."%(self,self.__dt)
-          self.checkPoint()
-          self.__tn+=self.__dt
-       self.doFinalization()
- class IterationDivergenceError(Exception):
-     """excpetion which should be thrown if an iteration at a time step fails"""
-     pass
- class FailedTimeStepError(Exception):
-     """excpetion which should be thrown if the time step fails because of a step size that have been choosen to be to large"""
-     pass
- class IllegalParameterError(Exception):
-     """excpetion which is thrown if model has not the desired parameter"""
-     pass
  if __name__=="__main__":
-    class Messenger(Model):
+     import math
-       def __init__(self):
+     #
-          Model.__init__(self,parameters={"message" : "none" },name="messenger")
+     # test for parameter set
+     #
-       def doInitialization(self):
+     p11=ParameterSet()
-          print "I start talking now!"
+     p11.declareParameter(gamma1=1.,gamma2=2.,gamma3=3.)
+     p1=ParameterSet()
-       def doStep(self,t):
+     p1.declareParameter(dim=2,tol_v=0.001,output_file="/tmp/u.%3.3d.dx",runFlag=True,parm11=p11)
-          print "Message (time %e) : %s "%(t,self.message)
+     parm=ParameterSet({ "parm1" : p1 , "parm2" : ParameterSet(["alpha"])})
+     parm.parm2.alpha=Link(p11,"gamma1")
+     parm.x="that should not be here!"
+     print parm.showParameters()
+     # should be something like: {"parm2" : {"alpha" : reference to attribute
+     # gamma1 of <__main__.ParameterSet instance at 0xf6db51cc>},"parm1" : {"dim"
+     # : 2,"runFlag" : True,"tol_v": 0.001,"parm11" : {"gamma3" : 3.0,"gamma2" :
+     # 2.0,"gamma1" : 1.0},"output_file" : /tmp/u.%3.3d.dx}}
+     assert parm.parm2.alpha==1.
+     parm.writeXML()
+     #=======================
+     class Messenger(Model):
+         def __init__(self):
+             Model.__init__(self)
+             self.declareParameter(message="none")
+         def doInitialization(self,t):
+             self.__t=t
+             print "I start talking now!"
+         def doStep(self,dt):
+             self.__t+=dt
+             print "Message (time %e) : %s "%(self.__t,self.message)
-       def doFinalization(self):
+         def doFinalization(self):
-          print "I have no more to say!"
+             print "I have no more to say!"
-    # explicit scheme
+     class ODETEST(Model):
-    class  Ode1(Model):
+         """ implements a solver for the ODE
-       def __init__(self,**args):
-            Model.__init__(self,parameters={"tend" : 1., "dt" : 0.0001 ,"a" : 0.1 ,"u" : 1. , "message" : "none" },name="Ode1",debug=True)
-       def doInitialization(self):
-            self._tn=0
-       def doStep(self,t):
-            self.u=self.u+(t-self._tn)*self.a*self.u**2
-            self._tn=t
-       def doFinalization(self):
-            self.message="current error = %e"%abs(self.u-1./(1./3.-self.a*self._tn))
-            print self.message
-       def getSafeTimeStepSize(self):
-            return self.dt
-       def finalize(self):
-            return self._tn>=self.tend
-    # explicit scheme
-    class  Ode2(Model):
-        def __init__(self,**args):
-            Model.__init__(self,parameters={"tend" : 1., "dt" : 0.0001 ,"a" : 0.1 ,"u" : 10000. },name="Ode2",debug=True)
-            self.declareParameter(tol=1.e-8,message="none")
-        def doInitialization(self):
-            self._tn=0
-            self._iter=0
-        def doIterationInitialization(self,t):
-             self._iter=0
-             self._u_last=self.u
-             self._dt=t-self._tn
-             self._tn=t
-        def doIterationStep(self):
-           self._iter+=1
-           self._u_old=self.u
-           self.u=(self._dt*self.a*self.u**2-self._u_last)/(2*self._dt*self.a*self.u-1.)
-        def terminate(self):
-           if self._iter<1:
-               return False
-           else:
-              return abs(self._u_old-self.u)<self.tol*abs(self.u)
-        def doIterationFinalization(self):
-            self.message="current error = %e"%abs(self.u-1./(1-self.a*self._tn))
-            print self.message
-        def getSafeTimeStepSize(self):
-            return self.dt
-        def finalize(self):
-             return self._tn>=self.tend
-    # a simple model with paramemter tend, dt, p1, p2, and p3
-    class Test1(Model):
-        def __init__(self,**args):
-            Model.__init__(self,{"tend" : 1., "dt" : 0.1 ,"p1" : 0 ,"p2" : 0 ,"p3" : 0 },"test","bla",None,True)
-            self.setParameters(args)
-        def doInitialization(self):
-            self.__tn=0
-            self.__n=0
-        def doStep(self,t):
-            self.p3=self.p1+t*self.p2
-            self.__tn=t
-            print "test1 set the value out1 to ",self.p3
-        def doFinalization(self):
+               du/dt=a*u+f(t)
-            pass
-        def getSafeTimeStepSize(self):
+            we use a implicit euler scheme :
-            return self.dt
-        def finalize(self):
-             return self._tn>self.tend
+               u_n-u_{n-1}= dt*a u_n + st*f(t_n)
-    class Test2(Model):
+            to get u_n we run an iterative process
+                u_{n.k}=u_{n-1}+dt*(a u_{n.i-1} + f(t_n))
-        def __init__(self):
-            Model.__init__(self,{"q1": None},"test2","",None,True)
+            input for this model are step size dt, end time tend and a value for
+            a, f and initial value for u. we need also a tolerance tol for a
+            stopping criterion.
-        def doInitialization(self):
+         """
-            print "the whole thing starts"
-        def doStep(self,t):
+         def __init__(self):
-            print "test2 things that out1 is now ",self.out1
+             Model.__init__(self,debug=True)
+             self.declareParameter(tend=1.,dt=0.1,a=0.9,u=10.,f=0.,message="",tol=1.e-8)
-        def doFinalization(self):
+         def doInitialization(self,t):
-            print "all done"
+             self.__tn=t
+             self.__iter=0
+         def doIterationInitialization(self,dt):
+             self.__iter=0
+             self.__u_last=self.u
-        def finalize(self):
+         def doIterationStep(self,dt):
-             return True
+             self.__iter+=1
+             self.__u_old=self.u
+             self.u=self.__u_last+dt*(self.a*self.__u_old+self.f)
+         def terminate(self):
+             if self.__iter<1:
+                 return False
+             else:
+                 return abs(self.__u_old-self.u)<self.tol*abs(self.u)
-    class Test12(Model):
+         def doIterationFinalization(self,dt):
-      """model build from two models in a transperent way"""
+             self.__tn+=dt
-      def __init__(self):
+             self.message="current error = %e"%abs(self.u-10.*math.exp((self.a-1.)*self.__tn))
-          Model.__init__(self,{"sm1": None, a : 0, "sm2": None},"test2","",None,True)
-          self.setExecutionOrder(["sm2","sm1"])
+         def getSafeTimeStepSize(self,dt):
+             return min(self.dt,1./(abs(self.a)+1.))
-    # test messenger
-    m=Messenger()
+         def finalize(self):
-    m.run()
+             return self.__tn>=self.tend
-    # ode1
-    o=Ode1()
+     #
-    o.dt=0.001
+     #   s solves the coupled ODE:
-    o.u=3.
+     #
-    o.run()
+     #     du/dt=a*u+  v
-    # ode1
+     #     dv/dt=  u+a*v
-    o=Ode2()
+     #
-    o.dt=0.01
+     #   each equation is treated through the ODETEST class. The equations are
-    o.a=0.1
+     #   linked and iteration over each time step is performed.  the current
-    o.u=1.
+     #   error of v is reported by the Messenger class.
-    o.run()
+     #
-    # and they are linked together:
+     o1=ODETEST()
-    o=Ode2()
+     o1.u=10
-    m=Messenger()
+     o2=ODETEST()
-    om=Model(submodels=[o,m],debug=True)
+     o2.u=-10.
-    om.dt=0.01
+     o1.f=Link(o2,"u")
-    om.u=1.
+     o2.f=Link(o1,"u")
-    m.message=Link(o)
+     m=Messenger()
-    om.run()
+     o1.dt=0.01
-    print om.showParameters()
+     m.message=Link(o1)
-/0
+     s=ExplicitSimulation([Simulation([o1,o2],debug=True),m],debug=True)
+     s.run()
-    t=Test1()
+     s.writeXML()
-    t.tend=1.
-    t.dt=0.25
-    t.in1=1.
-    t.in2=3.
-    t.run()
-    # and a coupled problem:
-    t2=Test2()
-    t2.out1=Link(t)
-    Model([t,t2],debug=True).run()

 Legend:



Removed from v.121
 


changed lines


 
Added in v.142
 Legend:



Removed from v.121
 


changed lines


 
Added in v.142
-Removed from v.121
+Added in v.142

	ViewVC Help
Powered by ViewVC 1.1.26