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

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

Parent Directory | Revision Log | View Patch Patch

-revision 122 by jgs,
Thu Jun  9 05:38:05 2005 UTC
+revision 123 by jgs,
Fri Jul  8 04:08:13 2005 UTC
 Line 2
  from types import StringType,IntType,FloatType,BooleanType,ListType,DictType
  from sys import stdout
+ import itertools
- from xml.dom import minidom
+ import modellib
+ # import the 'set' module if it's not defined (python2.3/2.4 difference)
+ try:
+     set
+ except NameError:
+     from sets import Set as set
- _HEADER_START="<?xml version=\"1.0\"?><ESyS>\n"
+ from xml.dom import minidom
- _HEADER_END="<\ESyS>\n"
  def dataNode(document, tagName, data):
      t = document.createTextNode(str(data))
      n = document.createElement(tagName)
      n.appendChild(t)
      return n
  def esysDoc():
      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:
      """
      a Link makes an attribute of an object callable:
            o.object()
            o.a=8
            l=Link(o,"a")
            assert l()==8
       """
-     def __init__(self,target=None,attribute=None):
+     def __init__(self,target,attribute=None):
          """creates a link to the object target. If attribute is given, the link is
          establised to this attribute of the target.  Otherwise the attribute is
          undefined."""
-         self.__target=target
+         self.target = target
-         self.setAttributeName(attribute)
+         self.attribute = None
+         self.setAttributeName(attribute)
-     def setAttributeName(self,name):
-         """set a new attribute name to be collected from the target object. The
+     def setAttributeName(self,attribute):
-         target object must have the attribute with name name."""
+         """set a new attribute name to be collected from the target object. The
-         if not name==None:
+         target object must have the attribute with name attribute."""
-             if not hasattr(self.__target,name):
+         if attribute and self.target and not hasattr(self.target, attribute):
-                 raise AttributeError("%s: target %s has no attribute %s."%(self,self.__target,name))
+             raise AttributeError("%s: target %s has no attribute %s."%(self, self.target, attribute))
-         self.__attribute=name
+         self.attribute = attribute
      def hasDefinedAttributeName(self):
          """returns true if an attribute name is set"""
-         if self.__attribute==None:
+         return self.attribute != None
-             return False
-         else:
+     def __repr__(self):
-             return True
+         """returns a string representation of the link"""
+         if self.hasDefinedAttributeName():
-     def __str__(self):
+             return "<Link to attribute %s of %s>" % (self.attribute, self.target)
-         """returns a string representation of the link"""
+         else:
-         if self.hasDefinedAttributeName():
+             return "<Link to target %s>" % self.target
-             return "reference to attribute %s of %s"%(self.__attribute,self.__target)
-         else:
+     def __call__(self,name=None):
-             return "reference to target %s"%self.__target
+         """returns the value of the attribute of the target object. If the
+         atrribute is callable then the return value of the call is returned."""
-     def __call__(self,name=None):
+         if name:
-         """returns the value of the attribute of the target object. If the
+             out=getattr(self.target, name)
-         atrribute is callable then the return value of the call is returned."""
+         else:
-         if not name == None:
+             out=getattr(self.target, self.attribute)
-             out=getattr(self.__target, name)
-         else:
+         if callable(out):
-             out=getattr(self.__target, self.__attribute)
+             return out()
-         if callable(out):
+         else:
-             return 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
-     def toDom(self, document, node):
+         document """
-         """ toDom method of Link. Creates a Link node and appends it to the current XML
+         link = document.createElement('Link')
-         document """
+         link.appendChild(dataNode(document, 'Target', self.target.id))
-         link = document.createElement('link')
+         # this use of id will not work for purposes of being able to retrieve the intended
-         link.appendChild(dataNode(document, 'target', id(self.__target)))
+         # target from the xml later. I need a better unique identifier.
-         link.appendChild(dataNode(document, 'attribute', self.__attribute))
+         assert self.attribute, "You can't xmlify a Link without a target attribute"
-         node.appendChild(link)
+         link.appendChild(dataNode(document, 'Attribute', self.attribute))
+         node.appendChild(link)
-     def writeXML(self,ostream=stdout):
-         """writes an XML representation of self to the output stream ostream.
+     def fromDom(cls, doc):
-         If ostream is nor present the standart output stream is used.  If
+         targetid = doc.getElementsByTagName("Target")[0].firstChild.nodeValue.strip()
-         esysheader==True the esys XML header is written"""
+         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
+     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")
+            p = LinkableObject()
-            print p.x
+            p.x = Link(o,"name")
+            print p.x
-         links attribute x of p to the attribute name of object o. p.x will print
-         the current value of attribute name of object o.  if the value is
+     links attribute x of p to the attribute name of object o.
-         callable p.x will rturn the return value of the call.
-     """
+     p.x will contain the current value of attribute name of object o.
-     def __init__(self,debug=False):
+     If the value of getattr(o, "name") is callable, p.x will rturn the return
-         """initiates a model from a list of subsimulations. """
+     value of the call.
-         self.setDebug(debug)
+     """
-         self.__linked_attributes={}
-     #
+     number_sequence = itertools.count(100)
-     # some basic fuctions:
-     #
+     def __init__(self, debug=False):
-     def debugOn(self):
+         """ initializes LinkableObject so that we can operate on Links """
-         """sets debugging to on"""
+         self.debug = debug
-         self.__debug=True
+         self.__linked_attributes={}
-     def debugOff(self):
+         self.id = self.number_sequence.next()
-         """sets debugging to off"""
-         self.__debug=False
+     def trace(self, msg):
-     def debug(self):
+         """ If debugging is on, print the message, otherwise do nothing
-         """returns True if debug mode is set to on"""
+         """
-         return self.__debug
+         if self.debug:
-     def setDebug(self,flag=False):
+             print msg
-         """sets debugging to flag"""
-         if flag:
+     def __getattr__(self,name):
-             self.debugOn()
+         """returns the value of attribute name. If the value is a Link object the
-         else:
+         object is called and the return value is returned."""
-             self.debugOff()
+         out = self.getAttributeObject(name)
+         if isinstance(out,Link):
-     def trace(self, msg):
+             return out()
-         if self.__debug:
+         else:
-             print msg
+             return out
-     def __getattr__(self,name):
+     def getAttributeObject(self,name):
-         """returns the value of attribute name. If the value is a Link object the
+         """return the object stored for attribute name."""
-         object is called and the return value is returned."""
-         out=self.getAttributeObject(name)
+         if self.__dict__.has_key(name):
-         if isinstance(out,Link):
+             return self.__dict__[name]
-             return out()
-         else:
+         if self.__linked_attributes.has_key(name):
-             return out
+             return self.__linked_attributes[name]
-     def getAttributeObject(self,name):
+         raise AttributeError,"No attribute %s."%name
-         """return the object stored for attribute name."""
-         if self.__dict__.has_key(name):
+     def __setattr__(self,name,value):
-             out=self.__dict__[name]
+         """sets the value for attribute name. If value is a Link the target
-         elif self.__linked_attributes.has_key(name):
+         attribute is set to name if no attribute has been specified."""
-             out=self.__linked_attributes[name]
-         else:
-             raise AttributeError,"No attribute %s."%name
+         if self.__dict__.has_key(name):
-         return out
+             del self.__dict__[name]
-     def __setattr__(self,name,value):
+         if isinstance(value,Link):
-         """sets the value for attribute name. If value is a Link the target
+             if not value.hasDefinedAttributeName():
-         attribute is set to name if no attribute has been specified."""
+                 value.setAttributeName(name)
-         if self.__dict__.has_key(name):
+             self.__linked_attributes[name] = value
-             del self.__dict__[name]
-         if isinstance(value,Link):
+             self.trace("DEBUG: %s: attribute %s is now linked by %s."%(self,name,value))
-            if not value.hasDefinedAttributeName():
+         else:
-                value.setAttributeName(name)
+             self.__dict__[name] = value
-            self.__linked_attributes[name]=value
-            if self.debug():
+     def __delattr__(self,name):
-                print "DEBUG: %s: attribute %s is now linked by %s."%(self,name,value)
+         """removes the attribute name."""
-         else:
-            self.__dict__[name]=value
+         if self.__linked_attributes.has_key[name]:
+             del self.__linked_attributes[name]
-     def __delattr__(self,name):
+         elif self.__dict__.has_key(name):
-         """removes the attribute name."""
+             del self.__dict__[name]
-         if self.__linked_attributes.has_key[name]:
+         else:
-             del self.__linked_attributes[name]
+             raise AttributeError,"No attribute %s."%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,debug=False):
+     def __init__(self,*args, **kwargs):
-         """initiates a simulation"""
+         """
-         LinkableObject.__init__(self,debug)
+         Initialises a simulation
-     def doInitialization(self,t):
+         Just calls the parent constructor.
-         """initializes the time stepping scheme. This function may be
+         """
-         overwritten."""
+         LinkableObject.__init__(self,*args, **kwargs)
-         pass
+     def doInitialization(self,t):
-     def getSafeTimeStepSize(self,dt):
+         """initializes the time stepping scheme. This function may be
-         """returns a time step size which can savely be used. This function may
+         overwritten."""
-         be overwritten."""
+         pass
-         return self.UNDEF_DT
+     def getSafeTimeStepSize(self,dt):
-     def finalize(self):
+         """returns a time step size which can savely be used. This function may
-         """returns True if the time stepping is finalized. This function may be
+         be overwritten."""
-         overwritten."""
+         return self.UNDEF_DT
-         return True
+     def finalize(self):
-     def doFinalization(self):
+         """returns True if the time stepping is finalized. This function may be
-         """finalizes the time stepping.  This function may be overwritten."""
+         overwritten."""
-         pass
+         return True
-     def doIterationInitialization(self,dt):
+     def doFinalization(self):
-         """initializes the iteration at time step t. This function may be
+         """finalizes the time stepping.  This function may be overwritten."""
-         overwritten. (only called if doStep is not overwritten)"""
+         pass
-         pass
+     def doIterationInitialization(self,dt):
-     def doIterationStep(self,dt):
+         """initializes the iteration at time step t. This function may be
-         """executes the iteration step. This function may be overwritten. (only
+         overwritten. (only called if doStep is not overwritten)"""
-         called if doStep is not overwritten)"""
+         pass
-         pass
+     def doIterationStep(self,dt):
-     def terminate(self):
+         """executes the iteration step. This function may be overwritten. (only
-         """returns True if iteration on a time step is terminated. (only called
+         called if doStep is not overwritten)"""
-         if doStep is not overwritten)"""
+         pass
-         return True
+     def terminate(self):
-     def doIterationFinalization(self,dt):
+         """returns True if iteration on a time step is terminated. (only called
-         """finalalizes the iteration process. (only called if doStep is not
+         if doStep is not overwritten)"""
-         overwritten)"""
+         return True
-         pass
+     def doIterationFinalization(self,dt):
-     def run(self,check_point=None):
+         """finalalizes the iteration process. (only called if doStep is not
-         """run the simulation by performing essentially
+         overwritten)"""
+         pass
-             self.doInitialization()
-             while not self.finalize():
+     def run(self,check_point=None):
-                dt=self.getSafeTimeStepSize()
+         """run the simulation by performing essentially
-                self.doStep(dt)
-                if n%check_point==0: self.writeXML()
+             self.doInitialization()
-             self.doFinalization()
+             while not self.finalize():
+                dt=self.getSafeTimeStepSize()
-         """
+                self.doStep(dt)
-         self.__tn=0.
+                if n%check_point==0: self.writeXML()
-         self.__n=0
+             self.doFinalization()
-         self.__dt=None
-         self.doInitialization(self.__tn)
+         """
-         while not self.finalize():
+         self.__tn=0.
-             self.__n+=1
+         self.__n=0
-             self.__dt=self.getSafeTimeStepSize(self.__dt)
+         self.__dt=None
-             if self.__dt==None: self.__dt=self.UNDEF_DT
+         self.doInitialization(self.__tn)
-             if not self.__dt>0:
+         while not self.finalize():
-                  raise NonPositiveStepSizeError("non-positive step size in step %d",self.__n)
+             self.__n+=1
-             if self.debug(): print "%s: %d. time step %e (step size %e.)"%(self,self.__n,self.__tn+self.__dt,self.__dt)
+             self.__dt=self.getSafeTimeStepSize(self.__dt)
-             endoftimestep=False
+             if self.__dt==None: self.__dt=self.UNDEF_DT
-             failcounter=0
+             if not self.__dt>0:
-             while not endoftimestep:
+                  raise NonPositiveStepSizeError("non-positive step size in step %d",self.__n)
-                 endoftimestep=True
+             self.trace("%s: %d. time step %e (step size %e.)" %
-                 try:
+                           (self,self.__n,self.__tn+self.__dt,self.__dt))
-                     self.doStep(self.__dt)
+             endoftimestep=False
-                 except FailedTimeStepError:
+             failcounter=0
-                     self.__dt=self.getSafeTimeStepSize(self.__dt)
+             while not endoftimestep:
-                     if self.__dt==None: self.__dt=self.UNDEF_DT
+                 endoftimestep=True
-                     endoftimestep=False
+                 try:
-                     if self.debug(): print "%s: time step is repeated with new step size %e."%(self,self.__dt)
+                     self.doStep(self.__dt)
-                 except IterationDivergenceError:
+                 except FailedTimeStepError:
-                     self.__dt*=0.5
+                     self.__dt=self.getSafeTimeStepSize(self.__dt)
-                     endoftimestep=False
+                     if self.__dt==None: self.__dt=self.UNDEF_DT
-                     failcounter+=1
+                     endoftimestep=False
-                     if failcounter>self.MAX_TIME_STEP_REDUCTION:
+                     self.trace("%s: time step is repeated with new step size %e."%(self,self.__dt))
-                         raise IterationBreakDownError("reduction of time step to achieve convergence failed.")
+                 except IterationDivergenceError:
+                     self.__dt*=0.5
-                     self.trace("%s: iteration failes. time step is repeated with new step size %e."
+                     endoftimestep=False
-                         % (self,self.__dt))
+                     failcounter+=1
-             self.__tn+=self.__dt
+                     if failcounter>self.MAX_TIME_STEP_REDUCTION:
-             if not check_point==None:
+                         raise IterationBreakDownError("reduction of time step to achieve convergence failed.")
-                 if self.__n%check_point==0:
-                     self.trace("%s: check point is created."%self)
+                     self.trace("%s: iteration failes. time step is repeated with new step size %e."
-                     self.writeXML()
+                         % (self,self.__dt))
-         self.doFinalization()
+             self.__tn+=self.__dt
+             if not check_point==None:
-     def writeXML(self):
+                 if self.__n%check_point==0:
-         raise RuntimeError, "Not implemented"
+                     self.trace("%s: check point is created."%self)
+                     self.writeXML()
-     def doStep(self,dt):
+         self.doFinalization()
-         """executes a time step by iteration. This function may be overwritten.
+     def writeXML(self):
-            basicly it performs :
+         raise RuntimeError, "Not implemented"
-             self.doIterationInitialization(dt)
+     def doStep(self,dt):
-             while not self.terminate(): self.doIterationStep(dt)
+         """executes a time step by iteration. This function may be overwritten.
-             self.doIterationFinalization(dt)
+            basicly it performs :
-         """
-         self.doIterationInitialization(dt)
+             self.doIterationInitialization(dt)
-         self.__iter=0
+             while not self.terminate(): self.doIterationStep(dt)
-         while not self.terminate():
+             self.doIterationFinalization(dt)
-             if self.debug(): print "%s: iteration step %d"%(self,self.__iter)
-             self.doIterationStep(dt)
+         """
-             self.__iter+=1
+         self.doIterationInitialization(dt)
-             if self.__iter>self.MAX_ITER_STEPS:
+         self.__iter=0
-                 raise IterationDivergenceError("%s: divergence in step %d"%(self,self.__iter))
+         while not self.terminate():
-         self.doIterationFinalization(dt)
+             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=[],debug=False):
+     def __init__(self, subsimulations=[], *args, **kwargs):
          """initiates a simulation from a list of subsimulations. """
-         SimulationFrame.__init__(self,debug)
+         SimulationFrame.__init__(self, *args, **kwargs)
          self.__subsimulations=[]
-         for i in range(len(subsimulations)): self[i]=subsimulations[i]
+         for i in range(len(subsimulations)):
-     def iterSubsimulations(self):
+             self[i] = subsimulations[i]
-         """returns an iterator over the subsimulations"""
-         return self.__subsimulations
+     def iterSubsimulations(self):
+         """returns an iterator over the subsimulations"""
-     def __getitem__(self,i):
+         return self.__subsimulations
-         """returns the i-th subsimulation"""
-         return self.__subsimulations[i]
+     def __getitem__(self,i):
+         """returns the i-th subsimulation"""
-     def __setitem__(self,i,value):
+         return self.__subsimulations[i]
-         """sets the i-th subsimulation"""
-         if not isinstance(value,SimulationFrame):
+     def __setitem__(self,i,value):
-             raise ValueError("assigned value is not a Simulation")
+         """sets the i-th subsimulation"""
-         for j in range(max(i-len(self.__subsimulations)+1,0)): self.__subsimulations.append(None)
+         if not isinstance(value,SimulationFrame):
-         self.__subsimulations[i]=value
+             raise ValueError("assigned value is not a Simulation")
+         for j in range(max(i-len(self.__subsimulations)+1,0)): self.__subsimulations.append(None)
-     def __len__(self):
+         self.__subsimulations[i]=value
-         """returns the number of subsimulations"""
-         return len(self.__subsimulations)
+     def __len__(self):
+         """returns the number of subsimulations"""
-     def toDom(self, document, node):
+         return len(self.__subsimulations)
-         """ toDom method of Simualtion class """
-         simulation = document.createElement('Simulation')
+     def toDom(self, document, node):
-         simulation.setAttribute('type', self.__class__.__name__)
+         """ toDom method of Simulation class """
+         simulation = document.createElement('Simulation')
-         for rank, sim in enumerate(self.iterSubsimulations()):
+         simulation.setAttribute('type', self.__class__.__name__)
-             component = document.createElement('Component')
-             component.setAttribute('rank', str(rank))
+         for rank, sim in enumerate(self.iterSubsimulations()):
+             component = document.createElement('Component')
-             sim.toDom(document, component)
+             component.setAttribute('rank', str(rank))
-             simulation.appendChild(component)
+             sim.toDom(document, component)
-         node.appendChild(simulation)
+             simulation.appendChild(component)
-     def writeXML(self,ostream=stdout):
+         node.appendChild(simulation)
-         """writes the object as an XML object into an output stream"""
-         document, rootnode = esysDoc()
+     def writeXML(self,ostream=stdout):
-         self.toDom(document, rootnode)
+         """writes the object as an XML object into an output stream"""
-         ostream.write(document.toprettyxml())
+         document, rootnode = esysDoc()
+         self.toDom(document, rootnode)
-     def getSafeTimeStepSize(self,dt):
+         ostream.write(document.toprettyxml())
-         """returns a time step size which can savely be used by all subsimulations"""
-         out=self.UNDEF_DT
+     def getSafeTimeStepSize(self,dt):
-         for i in self.iterSubsimulations():
+         """returns a time step size which can safely be used by all subsimulations"""
-             dt_new=i.getSafeTimeStepSize(dt)
+         out=self.UNDEF_DT
-             if dt_new!=None: out=min(out,dt_new)
+         for o in self.iterSubsimulations():
-         return out
+             dt_new = o.getSafeTimeStepSize(dt)
+             if dt_new != None:
-     def doInitialization(self,dt):
+                 out = min(out,dt_new)
-         """initializes all subsimulations """
-         for i in self.iterSubsimulations(): i.doInitialization(dt)
+         return out
-     def finalize(self):
+     def doInitialization(self,dt):
-         """returns True if all subsimulations are finalized"""
+         """initializes all subsimulations """
-         out=True
+         for o in self.iterSubsimulations():
-         for i in self.iterSubsimulations(): out = out and i.finalize()
+             o.doInitialization(dt)
-         return out
+     def finalize(self):
-     def doFinalization(self):
+         """returns True if all subsimulations are finalized"""
-         """finalalizes the time stepping for all subsimulations."""
+         return all([o.finalize() for o in self.iterSubsimulations()])
-         for i in self.iterSubsimulations(): i.doFinalization()
+     def doFinalization(self):
-     def doIterationInitialization(self,dt):
+         """finalalizes the time stepping for all subsimulations."""
-         """initializes the iteration at time t for all subsimulations."""
+         for i in self.iterSubsimulations(): i.doFinalization()
-         self.__iter=0
-         if self.debug(): print "%s: iteration starts"%self
+     def doIterationInitialization(self,dt):
-         for i in self.iterSubsimulations(): i.doIterationInitialization(dt)
+         """initializes the iteration at time t for all subsimulations."""
+         self.__iter=0
-     def terminate(self):
+         self.trace("%s: iteration starts"%self)
-         """returns True if all iterations for all subsimulations are terminated."""
-         out=True
+         for o in self.iterSubsimulations():
-         for i in self.iterSubsimulations(): out = out and i.terminate()
+             o.doIterationInitialization(dt)
-         return out
+     def terminate(self):
-     def doIterationFinalization(self,dt):
+         """returns True if all iterations for all subsimulations are terminated."""
-         """finalalizes the iteration process for each of the subsimulations."""
+         return all([o.terminate() for o in self.iterSubsimulations()])
-         for i in self.iterSubsimulations(): i.doIterationFinalization(dt)
-         if self.debug(): print "%s: iteration finalized after %s steps"%(self,self.__iter+1)
+     def doIterationFinalization(self,dt):
+         """finalalizes the iteration process for each of the subsimulations."""
-     def doIterationStep(self,dt):
+         for o in self.iterSubsimulations():
-         """executes the iteration step at time step for each subsimulation"""
+             o.doIterationFinalization(dt)
-         self.__iter+=1
+         self.trace("%s: iteration finalized after %s steps"%(self,self.__iter+1))
-         if self.debug(): print "%s: iteration step %d"%(self,self.__iter)
-         for i in self.iterSubsimulations(): i.doIterationStep(dt)
+     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)
+         for i in self.iterSubsimulations():
+             i.doStep(dt)
  class _ParameterIterator:
      def __init__(self,parameterset):
-         self.__set=parameterset
-         self.__iter=iter(parameterset.getParameterList())
+         self.__set=parameterset
-     def next(self):
+         self.__iter=iter(parameterset.parameters)
-         o=self.__iter.next()
-         return (o,self.__set.getAttributeObject(o))
+     def next(self):
-     def __iter__(self):
+         o=self.__iter.next()
-         return self
+         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=[]):
+     def __init__(self, parameters=[], **kwargs):
          """creates a ParameterSet with parameters parameters"""
-         LinkableObject.__init__(self,debug=False)
+         LinkableObject.__init__(self, **kwargs)
-         self.__parameters=[]
+         self.parameters = set()
          self.declareParameters(parameters)
-     def getParameterList(self):
+     def declareParameter(self,**parameters):
-         """returns the list of parameters"""
+         """declares a new parameter(s) and its (their) inital value."""
-         return self.__parameters
+         self.declareParameters(parameters)
-     def isParameter(self,name):
+     def declareParameters(self,parameters):
-         """returns true if name is a parameter"""
+         """declares a set of parameters. parameters can be a list, a dictonary or a ParameterSet."""
-         return name in self.getParameterList()
+         if isinstance(parameters,ListType):
+             parameters = zip(parameters, itertools.repeat(None))
-     def declareParameter(self,**parameters):
+         if isinstance(parameters,DictType):
-         """declares a new parameter(s) and its (their) inital value."""
+             parameters = parameters.iteritems()
-         self.declareParameters(parameters)
+         for prm, value in parameters:
-     def declareParameters(self,parameters):
+             setattr(self,prm,value)
-         """declares a set of parameters. parameters can be a list, a dictonary or a ParameterSet."""
+             self.parameters.add(prm)
-         if isinstance(parameters,ListType):
-             for prm in parameters:
+             self.trace("%s: parameter %s has been declared."%(self,prm))
-                 setattr(self,prm,None)
-                 if not self.isParameter(prm): self.getParameterList().append(prm)
+     def releaseParameters(self,name):
-                 if self.debug(): print "%s: parameter %s has been declared."%(self,prm)
+         """removes parameter name from the paramameters"""
-         elif isinstance(parameters,DictType):
+         if self.isParameter(name):
-             for prm,value in parameters.iteritems():
+             self.parameters.remove(name)
-                 setattr(self,prm,value)
+             self.debug("%s: parameter %s has been removed."%(self, name))
-                 if not self.isParameter(prm): self.getParameterList().append(prm)
-                 if self.debug(): print "%s: parameter %s has been declared."%(self,prm)
+     def __iter__(self):
-         else:
+         """creates an iterator over the parameter and their values"""
-             for prm,value in parameters:
+         return _ParameterIterator(self)
-                 setattr(self,prm,value)
-                 if not self.isParameter(prm): self.getParameterList().append(prm)
+     def showParameters(self):
-                 if self.debug(): print "%s: parameter %s has been declared."%(self,prm)
+         """returns a descrition of the parameters"""
+         out="{"
-     def releaseParameters(self,name):
+         notfirst=False
-         """removes parameter name from the paramameters"""
+         for i,v in self:
-         if self.isParameter(name):
+             if notfirst: out=out+","
-             self.getParameterList().remove(name)
+             notfirst=True
-             if self.debug(): print "%s: parameter %s has been removed."%(self,prm)
+             if isinstance(v,ParameterSet):
+                 out="%s\"%s\" : %s"%(out,i,v.showParameters())
-     def __iter__(self):
+             else:
-         """creates an iterator over the parameter and their values"""
+                 out="%s\"%s\" : %s"%(out,i,v)
-         return _ParameterIterator(self)
+         return out+"}"
-     def showParameters(self):
+     def __delattr__(self,name):
-         """returns a descrition of the parameters"""
+         """removes the attribute name."""
-         out="{"
+         LinkableObject.__delattr__(self,name)
-         notfirst=False
+         try:
-         for i,v in self:
+             self.releaseParameter(name)
-             if notfirst: out=out+","
+         except:
-             notfirst=True
+             pass
-             if isinstance(v,ParameterSet):
-                 out="%s\"%s\" : %s"%(out,i,v.showParameters())
+     def toDom(self, document, node):
-             else:
+         """ toDom method of ParameterSet class """
-                 out="%s\"%s\" : %s"%(out,i,v)
+         pset = document.createElement('ParameterSet')
-         return out+"}"
+         node.appendChild(pset)
+         self._parametersToDom(document, pset)
-     def __delattr__(self,name):
-         """removes the attribute name."""
+     def _parametersToDom(self, document, node):
-         LinkableObject.__delattr__(self,name)
+         node.setAttribute ('id', str(self.id))
-         try:
+         for name,value in self:
-             self.releaseParameter(name)
+             param = document.createElement('Parameter')
-         except:
+             param.setAttribute('type', value.__class__.__name__)
-             pass
+             param.appendChild(dataNode(document, 'Name', name))
-     def toDom(self, document, node):
-         """ toDom method of ParameterSet class """
+             val = document.createElement('Value')
-         pset = document.createElement('ParameterSet')
-         node.appendChild(pset)
+             if isinstance(value,ParameterSet):
-         self._parametersToDom(document, pset)
+                 value.toDom(document, val)
+                 param.appendChild(val)
-     def _parametersToDom(self, document, node):
+             elif isinstance(value, Link):
-         for name,value in self:
+                 value.toDom(document, val)
-             param = document.createElement('Parameter')
+                 param.appendChild(val)
-             param.setAttribute('type', value.__class__.__name__)
+             elif isinstance(value,StringType):
+                 param.appendChild(dataNode(document, 'Value', value))
-             param.appendChild(dataNode(document, 'Name', name))
+             else:
+                 param.appendChild(dataNode(document, 'Value', str(value)))
-             val = document.createElement('Value')
+             node.appendChild(param)
-             if isinstance(value,ParameterSet):
-                 value.toDom(document, val)
-             elif isinstance(value, Link):
+     def fromDom(cls, doc):
-                 value.toDom(document, val)
-                 param.appendChild(val)
+         # Define a host of helper functions to assist us.
-             elif isinstance(value,StringType):
+         def _children(node):
-                 param.appendChild(dataNode(document, 'Value', value))
+             """
-             else:
+             Remove the empty nodes from the children of this node
-                 param.appendChild(dataNode(document, 'Value', str(value)))
+             """
+             return [x for x in node.childNodes
-             node.appendChild(param)
+                     if not isinstance(x, minidom.Text) or x.nodeValue.strip()]
-     def writeXML(self,ostream=stdout):
+         def _floatfromValue(doc):
-         """writes the object as an XML object into an output stream"""
+             return float(doc.nodeValue.strip())
-         # ParameterSet(d) with d[Name]=Value
-         document, node = esysDoc()
+         def _stringfromValue(doc):
-         self.toDom(document, node)
+             return str(doc.nodeValue.strip())
-         ostream.write(document.toprettyxml())
+         # 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=[],*args,**kwargs):
+         """creates a model"""
+         ParameterSet.__init__(self, parameters=parameters)
+         SimulationFrame.__init__(self,*args,**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)
-     def __init__(self,debug=False):
-         """creates a model"""
-         ParameterSet.__init__(self)
-         SimulationFrame.__init__(self,debug=debug)
-     def writeXML(self,ostream=stdout,esysheader=True,modelheader=True):
-         """writes the object as an XML object into an output stream"""
-         # x=type() with x.Name=Value where type is a Model from the model library.
-         if esysheader: ostream.write(_HEADER_START)
-         ostream.write("<Model type=\"%s\" module=\"%s\">\n"%(self.__class__.__name__,self.__class__.__module__))
-         self. writeParameterXML(ostream)
-         ostream.write("</Model>\n")
-         if esysheader: ostream.write(_HEADER_END)
  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:
          class Messenger(Model):
              def __init__(self):
                 Model.__init__(self,parameters={"message" : "none" })
          m=MyModel()
         There are various ways how model parameters can be changed:
 ) use object attributes:
            m.message="Hello World!"
 ) use setParamter method
            m.setParameters(message="Hello World!")
 ) or dictonaries
             d={ message : "Hello World!" }
             m.setParameters(**d)
         A model executed buy staring the run method of the 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 to get from the current to the
         next time step. The step size is defined by calling the
         getSafeTimeStepSize() method.  the time integration process is
         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:
         class Messenger(Model):
              def __init__(self):
                 Model.__init__(self,parameters={"message" : "none" })
              def doInitialization(self):
                 print "I start talking now!"
              def doStep(self,t):
                 print "Message (time %e) : %s "%(t,self.message)
              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.  This is because the
         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:
                  u(t=0)=u0
                  u_t=a*u**2       for all 0<t<=ten
        exact solution is given by u(t)=1/(1/u0-a*t)
        class  Ode1(Model):
           def __init__(self,**args):
              Model.__init__(self,parameters={"tend" : 1., "dt" : 0.0001 ,"a" : 0.1 ,"u" : 1. },name="test",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):
               print "all done final error = ",abs(self.u-1./(1./3.-self.a*self._tn))
           def getSafeTimeStepSize(self):
               return self.dt
           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
         this case the doStep() method is replaced by a sequance of methods which
         implements this iterative process.  The method then will control the
         iteration process by initializing the iteration through calling the
         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
 = u_{n+1}-u_{n}+a*dt*u_{n+1}**2
         has to be solved for u_{n+1}. The Newton scheme is used to solve this non-linear problem.
        class  Ode2(Model):
         def __init__(self,**args):
             Model.__init__(self,{"tend" : 1., "dt" : 0.1 ,"a" : 10. ,"u" : 1. , "tol " : 1.e-8},"test","bla",None,True)
         def doInitialization(self):
             self.__tn=0
         def doIterationInitialization(self,t):
              self.__iter=0
              self.u_last=self.u
              self.current_dt=t-self.tn
              self.__tn=t
         def doIterationStep(self):
            self.__iter+=1
            self.u_old=self.u
            self.u=(self.current_dt*self.a*self.u**2-self.u_last)/(2*self.current_dt*self.a*self.u-1.)
         def terminate(self):
             return abs(self.u_old-self.u)<self.tol*abs(self.u)
         def doIterationFinalization(self)
             print "all done"
         def getSafeTimeStepSize(self):
             return self.dt
         def finalize(self):
              return self.__tn>self.tend
         A model can be composed from subsimulations. Subsimulations are treated
         as model parameters. If a model parameter is set or a value of a model
         parameter is requested, the model will search for this parameter its
         subsimulations in the case the model does not have this parameter
         itself. The order in which the subsimulations are searched is critical.
         By default a Model initializes all its subsimulations, is finalized when
         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(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
         automatically hand the assignment of new values down to the
         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.
         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 subsimulations are to be finalized. The simulation is processing
         in time through calling the stepForward methods which updates the
         observables of each subsimulation.  A time steps size which is save for
         all subsimulation is choosen.
         At given time step an iterative process may be performed to make sure
         that all observables are consistent across all subsimulations.  In this
         case, similar the time dependence, an initialization and finalization of
         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
         At any time the current value of the parameter name can be obtained by
                 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 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
         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.
         The run method initiates checkpointing (it is not clear how to do this
         yet)
     =====
     """
  if __name__=="__main__":
      import math
      #
      # test for parameter set
      #
      p11=ParameterSet()
      p11.declareParameter(gamma1=1.,gamma2=2.,gamma3=3.)
      p1=ParameterSet()
      p1.declareParameter(dim=2,tol_v=0.001,output_file="/tmp/u.%3.3d.dx",runFlag=True,parm11=p11)
      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):
              print "I have no more to say!"
      class ODETEST(Model):
          """ implements a solver for the ODE
                du/dt=a*u+f(t)
             we use a implicit euler scheme :
                u_n-u_{n-1}= dt*a u_n + st*f(t_n)
             to get u_n we run an iterative process
                 u_{n.k}=u_{n-1}+dt*(a u_{n.i-1} + f(t_n))
             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 __init__(self):
              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 doInitialization(self,t):
              self.__tn=t
              self.__iter=0
          def doIterationInitialization(self,dt):
              self.__iter=0
              self.__u_last=self.u
          def doIterationStep(self,dt):
              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)
          def doIterationFinalization(self,dt):
              self.__tn+=dt
              self.message="current error = %e"%abs(self.u-10.*math.exp((self.a-1.)*self.__tn))
          def getSafeTimeStepSize(self,dt):
              return min(self.dt,1./(abs(self.a)+1.))
          def finalize(self):
              return self.__tn>=self.tend
      #
      #   s solves the coupled ODE:
      #
      #     du/dt=a*u+  v
      #     dv/dt=  u+a*v
      #
      #   each equation is treated through the ODETEST class. The equations are
      #   linked and iteration over each time step is performed.  the current
      #   error of v is reported by the Messenger class.
      #
      o1=ODETEST()
      o1.u=10
      o2=ODETEST()
      o2.u=-10.
      o1.f=Link(o2,"u")
      o2.f=Link(o1,"u")
      m=Messenger()
      o1.dt=0.01
      m.message=Link(o1)
      s=ExplicitSimulation([Simulation([o1,o2],debug=True),m],debug=True)
      s.run()
      s.writeXML()

 Legend:



Removed from v.122
 


changed lines


 
Added in v.123
 Legend:



Removed from v.122
 


changed lines


 
Added in v.123
-Removed from v.122
+Added in v.123

	ViewVC Help
Powered by ViewVC 1.1.26