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

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

Parent Directory | Revision Log | View Patch Patch

-trunk/esys2/escript/py_src/modelframe.py
revision 147 by jgs,
Fri Aug 12 01:45:47 2005 UTC
+trunk/escript/py_src/modelframe.py
revision 885 by gross,
Wed Nov  1 09:05:51 2006 UTC
 Line 1
  # $Id$
+ """
+ Environment for implementing models in escript
+ @var __author__: name of author
+ @var __copyright__: copyrights
+ @var __license__: licence agreement
+ @var __url__: url entry point on documentation
+ @var __version__: version
+ @var __date__: date of the version
+ """
+ __author__="Lutz Gross, l.gross@uq.edu.au"
+ __copyright__="""  Copyright (c) 2006 by ACcESS MNRF
+                     http://www.access.edu.au
+                 Primary Business: Queensland, Australia"""
+ __license__="""Licensed under the Open Software License version 3.0
+              http://www.opensource.org/licenses/osl-3.0.php"""
+ __url__="http://www.iservo.edu.au/esys"
+ __version__="$Revision$"
+ __date__="$Date$"
  from types import StringType,IntType,FloatType,BooleanType,ListType,DictType
  from sys import stdout
+ import numarray
+ import operator
  import itertools
  # import modellib  temporarily removed!!!
-Line 15 
 from xml.dom import minidom
+Line 39 
 from xml.dom import minidom
  def dataNode(document, tagName, data):
      """
-     dataNodes are the building blocks of the xml documents constructed in
+     C{dataNode}s are the building blocks of the xml documents constructed in
-     this module. document is the current xml document, tagName is the
+     this module.
-     associated xml tag, and data is the values in the tag.
+     @param document: the current xml document
+     @param tagName: the associated xml tag
+     @param data: the values in the tag
      """
      t = document.createTextNode(str(data))
      n = document.createElement(tagName)
-Line 57 
 def registerLink(obj_id, l):
+Line 84 
 def registerLink(obj_id, l):
  def parse(xml):
      """
-     Generic parse method for EsysXML. Without this, Links don't work.
+     Generic parse method for EsysXML.  Without this, Links don't work.
      """
      global LinkRegistry, LinkableObjectRegistry
      LinkRegistry = []
-Line 70 
 def parse(xml):
+Line 97 
 def parse(xml):
      return sim
+ def importName(modulename, name):
+     """ Import a named object from a module in the context of this function,
+         which means you should use fully qualified module paths.
+         Return None on failure.
+         This function from: http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52241
+     """
+     module = __import__(modulename, globals(), locals(), [name])
+     try:
+         return vars(module)[name]
+     except KeyError:
+         raise ImportError("Could not import %s from %s" % (name, modulename))
  def getComponent(doc):
      """
      Used to get components of Simualtions, Models.
-Line 81 
 def getComponent(doc):
+Line 123 
 def getComponent(doc):
                  if node.getAttribute("type") == 'Simulation':
                      return Simulation.fromDom(node)
              if node.tagName == 'Model':
-                 model_type = node.getAttribute("type")
+                 if (node.getAttribute("module")):
-                 model_subclasses = Model.__subclasses__()
+                     model_module = node.getAttribute("module")
-                 for model in model_subclasses:
+                     model_type = node.getAttribute("type")
-                     if model_type == model.__name__:
+                     return importName(model_module, model_type).fromDom(node)
-                         return Model.fromDom(node)
+                 else:
+                     model_type = node.getAttribute("type")
+                     model_subclasses = Model.__subclasses__()
+                     for model in model_subclasses:
+                         if model_type == model.__name__:
+                             return Model.fromDom(node)
              if node.tagName == 'ParameterSet':
                  parameter_type = node.getAttribute("type")
                  return ParameterSet.fromDom(node)
-Line 97 
 def getComponent(doc):
+Line 144 
 def getComponent(doc):
  class Link:
      """
-     a Link makes an attribute of an object callable:
+     A Link makes an attribute of an object callable::
            o.object()
            o.a=8
            l=Link(o,"a")
-Line 106 
 class Link:
+Line 154 
 class Link:
      def __init__(self,target,attribute=None):
          """
-         creates a link to the object target. If attribute is given, the link is
+         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.
          """
-Line 116 
 class Link:
+Line 164 
 class Link:
      def setAttributeName(self,attribute):
          """
-         set a new attribute name to be collected from the target object. The
+         Set a new attribute name to be collected from the target object. The
          target object must have the attribute with name attribute.
          """
          if attribute and self.target:
-Line 130 
 class Link:
+Line 178 
 class Link:
      def hasDefinedAttributeName(self):
          """
-         returns true if an attribute name is set
+         Returns true if an attribute name is set.
          """
          return self.attribute != None
      def __repr__(self):
          """
-         returns a string representation of the link
+         Returns a string representation of the link.
          """
          if self.hasDefinedAttributeName():
              return "<Link to attribute %s of %s>" % (self.attribute, self.target)
-Line 145 
 class Link:
+Line 193 
 class Link:
      def __call__(self,name=None):
          """
-         returns the value of the attribute of the target object. If the
+         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:
-Line 160 
 class Link:
+Line 208 
 class Link:
      def toDom(self, document, node):
          """
-         toDom method of Link. Creates a Link node and appends it to the current XML
+         C{toDom} method of Link. Creates a Link node and appends it to the
-         document
+     current XML document.
          """
          link = document.createElement('Link')
          assert (self.target != None), ("Target was none, name was %r" % self.attribute)
-Line 183 
 class Link:
+Line 231 
 class Link:
      def writeXML(self,ostream=stdout):
          """
-         writes an XML representation of self to the output stream ostream.
+         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
          """
-Line 196 
 class Link:
+Line 244 
 class Link:
  class LinkableObject(object):
      """
      An object that allows to link its attributes to attributes of other objects
-     via a Link object. For instance
+     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.
+     links attribute C{x} of C{p} to the attribute name of object C{o}.
-     p.x will contain the current value of attribute name of object o.
+     C{p.x} will contain the current value of attribute C{name} of object
+     C{o}.
-     If the value of getattr(o, "name") is callable, p.x will rturn the return
+     If the value of C{getattr(o, "name")} is callable, C{p.x} will return
-     value of the call.
+     the return value of the call.
      """
      number_sequence = itertools.count(100)
      def __init__(self, debug=False):
-         """ initializes LinkableObject so that we can operate on Links """
+         """
+     Initializes LinkableObject so that we can operate on Links
+     """
          self.debug = debug
          self.__linked_attributes={}
          self.id = self.number_sequence.next()
+         registerLinkableObject(self.id, self)
      def trace(self, msg):
-         """ If debugging is on, print the message, otherwise do nothing
+         """
+     If debugging is on, print the message, otherwise do nothing
          """
          if self.debug:
              print "%s: %s"%(str(self),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."""
+     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()
-Line 234 
 class LinkableObject(object):
+Line 289 
 class LinkableObject(object):
              return out
      def getAttributeObject(self,name):
-         """return the object stored for attribute name."""
+         """
+     Return the object stored for attribute name.
+     """
          if self.__dict__.has_key(name):
              return self.__dict__[name]
-Line 248 
 class LinkableObject(object):
+Line 305 
 class LinkableObject(object):
          raise AttributeError,"No attribute %s."%name
      def hasAttribute(self,name):
-         """returns True if self as attribute name"""
+         """
+     Returns True if self as attribute name.
+     """
          return self.__dict__.has_key(name) or self.__linked_attributes.has_key(name) or  self.__class__.__dict__.has_key(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."""
+     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]
-Line 269 
 class LinkableObject(object):
+Line 329 
 class LinkableObject(object):
              self.__dict__[name] = value
      def __delattr__(self,name):
-         """removes the attribute name."""
+         """
+     Removes the attribute name.
+     """
          if self.__linked_attributes.has_key[name]:
              del self.__linked_attributes[name]
-Line 292 
 class _ParameterIterator:
+Line 354 
 class _ParameterIterator:
          return self
  class ParameterSet(LinkableObject):
-     """a class which allows to emphazise attributes to be written and read to XML
+     """
+     A class which allows to emphazise attributes to be written and read to XML
-        Leaves of  an ESySParameters objects can be
+     Leaves of an ESySParameters object can be:
-             a real number
+      - a real number
-             a integer number
+      - a integer number
-             a string
+      - a string
-             a boolean value
+      - a boolean value
-             a ParameterSet object
+      - a ParameterSet object
-             a Simulation object
+      - a Simulation object
-             a Model object
+      - a Model object
-             any other object (not considered by writeESySXML and writeXML)
+      - a numarray object
+          - a list of booleans
-            Example how to create an ESySParameters object:
+         - any other object (not considered by writeESySXML and writeXML)
-                  p11=ParameterSet(gamma1=1.,gamma2=2.,gamma3=3.)
+     Example how to create an ESySParameters object::
-                  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")))
+         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)
-            This can be accessed as
+         parm=ParameterSet(parm1=p1,parm2=ParameterSet(alpha=Link(p11,"gamma1")))
-                  parm.parm1.gamma=0.
+     This can be accessed as::
-                  parm.parm1.dim=2
-                  parm.parm1.tol_v=0.001
+     parm.parm1.gamma=0.
-                  parm.parm1.output_file="/tmp/u.%3.3d.dx"
+         parm.parm1.dim=2
-                  parm.parm1.runFlag=True
+         parm.parm1.tol_v=0.001
-                  parm.parm1.parm11.gamma1=1.
+         parm.parm1.output_file="/tmp/u.%3.3d.dx"
-                  parm.parm1.parm11.gamma2=2.
+         parm.parm1.runFlag=True
-                  parm.parm1.parm11.gamma3=3.
+         parm.parm1.parm11.gamma1=1.
-                  parm.parm2.alpha=1. (value of parm.parm1.parm11.gamma1)
+         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"""
+         """
+     Creates a ParameterSet with parameters parameters.
+     """
          LinkableObject.__init__(self, **kwargs)
          self.parameters = set()
          self.declareParameters(parameters)
-Line 335 
 class ParameterSet(LinkableObject):
+Line 401 
 class ParameterSet(LinkableObject):
                              [(p, getattr(self, p, None)) for p in self.parameters])
      def declareParameter(self,**parameters):
-         """declares a new parameter(s) and its (their) inital value."""
+         """
+     Declares a new parameter(s) and its (their) initial value.
+     """
          self.declareParameters(parameters)
      def declareParameters(self,parameters):
-         """declares a set of parameters. parameters can be a list, a dictonary or a ParameterSet."""
+         """
+     Declares a set of parameters. parameters can be a list, a dictionary
+     or a ParameterSet.
+     """
          if isinstance(parameters,ListType):
              parameters = zip(parameters, itertools.repeat(None))
          if isinstance(parameters,DictType):
-Line 352 
 class ParameterSet(LinkableObject):
+Line 423 
 class ParameterSet(LinkableObject):
              self.trace("parameter %s has been declared."%prm)
      def releaseParameters(self,name):
-         """removes parameter name from the paramameters"""
+         """
+     Removes parameter name from the paramameters.
+     """
          if self.isParameter(name):
              self.parameters.remove(name)
              self.trace("parameter %s has been removed."%name)
      def __iter__(self):
-         """creates an iterator over the parameter and their values"""
+         """
+     Creates an iterator over the parameter and their values.
+     """
          return _ParameterIterator(self)
      def showParameters(self):
-         """returns a descrition of the parameters"""
+         """
+     Returns a descrition of the parameters.
+     """
          out="{"
          notfirst=False
          for i,v in self:
-Line 375 
 class ParameterSet(LinkableObject):
+Line 452 
 class ParameterSet(LinkableObject):
          return out+"}"
      def __delattr__(self,name):
-         """removes the attribute name."""
+         """
+     Removes the attribute name.
+     """
          LinkableObject.__delattr__(self,name)
          try:
              self.releaseParameter(name)
-Line 383 
 class ParameterSet(LinkableObject):
+Line 462 
 class ParameterSet(LinkableObject):
              pass
      def toDom(self, document, node):
-         """ toDom method of ParameterSet class """
+         """
+     C{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))
+         node.setAttribute('id', str(self.id))
+         node.setIdAttribute("id")
          for name,value in self:
              param = document.createElement('Parameter')
              param.setAttribute('type', value.__class__.__name__)
-Line 398 
 class ParameterSet(LinkableObject):
+Line 480 
 class ParameterSet(LinkableObject):
              val = document.createElement('Value')
-             if isinstance(value,ParameterSet):
+             if isinstance(value,(ParameterSet,Link,DataSource)):
                  value.toDom(document, val)
                  param.appendChild(val)
-             elif isinstance(value, Link):
+             elif isinstance(value, numarray.NumArray):
-                 value.toDom(document, val)
+                 shape = value.getshape()
+                 if isinstance(shape, tuple):
+                     size = reduce(operator.mul, shape)
+                     shape = ' '.join(map(str, shape))
+                 else:
+                     size = shape
+                     shape = str(shape)
+                 arraytype = value.type()
+                 numarrayElement = document.createElement('NumArray')
+                 numarrayElement.appendChild(dataNode(document, 'ArrayType', str(arraytype)))
+                 numarrayElement.appendChild(dataNode(document, 'Shape', shape))
+                 numarrayElement.appendChild(dataNode(document, 'Data', ' '.join(
+                     [str(x) for x in numarray.reshape(value, size)])))
+                 val.appendChild(numarrayElement)
                  param.appendChild(val)
-             elif isinstance(value,StringType):
+             elif isinstance (value, list):
-                 param.appendChild(dataNode(document, 'Value', value))
+                 param.appendChild(dataNode(document, 'Value', ' '.join(
+                     [str(x) for x in value])
+                 ))
              else:
                  param.appendChild(dataNode(document, 'Value', str(value)))
-Line 416 
 class ParameterSet(LinkableObject):
+Line 514 
 class ParameterSet(LinkableObject):
          # Define a host of helper functions to assist us.
          def _children(node):
              """
-             Remove the empty nodes from the children of this node
+             Remove the empty nodes from the children of this node.
              """
-             return [x for x in node.childNodes
+             ret = []
-                     if not isinstance(x, minidom.Text) or x.nodeValue.strip()]
+             for x in node.childNodes:
+                 if isinstance(x, minidom.Text):
+                     if x.nodeValue.strip():
+                         ret.append(x)
+                 else:
+                     ret.append(x)
+             return ret
          def _floatfromValue(doc):
              return float(doc.nodeValue.strip())
-Line 431 
 class ParameterSet(LinkableObject):
+Line 535 
 class ParameterSet(LinkableObject):
              return int(doc.nodeValue.strip())
          def _boolfromValue(doc):
-             return bool(doc.nodeValue.strip())
+             return _boolfromstring(doc.nodeValue.strip())
+         def _nonefromValue(doc):
+             return None
+         def _numarrayfromValue(doc):
+             for node in _children(doc):
+                 if node.tagName == 'ArrayType':
+                     arraytype = node.firstChild.nodeValue.strip()
+                 if node.tagName == 'Shape':
+                     shape = node.firstChild.nodeValue.strip()
+                     shape = [int(x) for x in shape.split()]
+                 if node.tagName == 'Data':
+                     data = node.firstChild.nodeValue.strip()
+                     data = [float(x) for x in data.split()]
+             return numarray.reshape(numarray.array(data, type=getattr(numarray, arraytype)),
+                                     shape)
+         def _listfromValue(doc):
+             return [_boolfromstring(x) for x in doc.nodeValue.split()]
+         def _boolfromstring(s):
+             if s == 'True':
+                 return True
+             else:
+                 return False
          # 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,
+                     "DataSource":DataSource.fromDom,
                      "float":_floatfromValue,
                      "int":_intfromValue,
                      "str":_stringfromValue,
-                     "bool":_boolfromValue
+                     "bool":_boolfromValue,
+                     "list":_listfromValue,
+                     "NumArray":_numarrayfromValue,
+                     "NoneType":_nonefromValue,
                      }
  #        print doc.toxml()
-Line 458 
 class ParameterSet(LinkableObject):
+Line 591 
 class ParameterSet(LinkableObject):
                  if childnode.tagName == "Value":
                      nodes = _children(childnode)
+                 #    if ptype == 'NumArray':
+                  #       pvalue = _numarrayfromValue(nodes)
+                  #   else:
                      pvalue = ptypemap[ptype](nodes[0])
              parameters[pname] = pvalue
-Line 471 
 class ParameterSet(LinkableObject):
+Line 607 
 class ParameterSet(LinkableObject):
      fromDom = classmethod(fromDom)
      def writeXML(self,ostream=stdout):
-         """writes the object as an XML object into an output stream"""
+         """
+     Writes the object as an XML object into an output stream.
+     """
          # ParameterSet(d) with d[Name]=Value
          document, node = esysDoc()
          self.toDom(document, node)
-Line 479 
 class ParameterSet(LinkableObject):
+Line 617 
 class ParameterSet(LinkableObject):
  class Model(ParameterSet):
      """
+     A Model object represents a processess marching over time until a
-     A Model object represents a processess marching over time
+     finalizing condition is fullfilled. At each time step an iterative
-     until a finalizing condition is fullfilled. At each time step an iterative
+     process can be performed and the time step size can be controlled. A
-     process can be performed and the time step size can be controlled. A Model has
+     Model has the following work flow::
-     the following work flow:
            doInitialization()
            while not finalize():
-Line 493 
 class Model(ParameterSet):
+Line 630 
 class Model(ParameterSet):
                 doStepPostprocessing(dt)
            doFinalization()
-           where doInitialization,finalize, getSafeTimeStepSize, doStepPreprocessing, terminateIteration, doStepPostprocessing, doFinalization
+     where C{doInitialization}, C{finalize}, C{getSafeTimeStepSize},
-           are methods of the particular instance of a Model. The default implementations of these methods have to be overwritten by
+     C{doStepPreprocessing}, C{terminateIteration}, C{doStepPostprocessing},
-           the subclass implementinf a Model.
+     C{doFinalization} are methods of the particular instance of a Model. The
+     default implementations of these methods have to be overwritten by the
+     subclass implementing a Model.
      """
      UNDEF_DT=1.e300
      def __init__(self,parameters=[],**kwarg):
-         """creates a model
+         """
+     Creates a model.
-             Just calls the parent constructor.
+         Just calls the parent constructor.
          """
          ParameterSet.__init__(self, parameters=parameters,**kwarg)
-Line 512 
 class Model(ParameterSet):
+Line 651 
 class Model(ParameterSet):
         return "<%s %d>"%(self.__class__,id(self))
      def toDom(self, document, node):
-         """ toDom method of Model class """
+         """
+     C{toDom} method of Model class
+     """
          pset = document.createElement('Model')
          pset.setAttribute('type', self.__class__.__name__)
+         if not self.__class__.__module__.startswith('esys.escript'):
+             pset.setAttribute('module', self.__class__.__module__)
          node.appendChild(pset)
          self._parametersToDom(document, pset)
      def doInitialization(self):
-         """initializes the time stepping scheme. This function may be overwritten."""
+         """
+     Initializes the time stepping scheme.
+     This function may be overwritten.
+     """
          pass
      def getSafeTimeStepSize(self,dt):
-         """returns a time step size which can safely be used.
+         """
-            dt gives the previously used step size.
+     Returns a time step size which can safely be used.
-            This function may be overwritten."""
+         C{dt} gives the previously used step size.
+         This function may be overwritten.
+     """
          return self.UNDEF_DT
      def finalize(self):
-         """returns False if the time stepping is finalized. This function may be
+         """
-         overwritten."""
+     Returns False if the time stepping is finalized.
+     This function may be overwritten.
+     """
          return False
      def doFinalization(self):
-         """finalizes the time stepping. This function may be overwritten."""
+         """
+     Finalizes the time stepping.
+     This function may be overwritten.
+     """
          pass
      def doStepPreprocessing(self,dt):
-         """sets up a time step of step size dt. This function may be overwritten."""
+         """
+     Sets up a time step of step size dt.
+     This function may be overwritten.
+     """
          pass
      def doStep(self,dt):
-         """executes an iteration step at a time step.
+         """
-            dt is the currently used time step size.
+     Executes an iteration step at a time step.
-            This function may be overwritten."""
+         C{dt} is the currently used time step size.
+         This function may be overwritten.
+     """
          pass
      def terminateIteration(self):
-         """returns True if iteration on a time step is terminated."""
+         """
+     Returns True if iteration on a time step is terminated.
+     """
          return True
      def doStepPostprocessing(self,dt):
-         """finalalizes the time step.
+         """
-            dt is the currently used time step size.
+     Finalalizes the time step.
-            This function may be overwritten."""
+         dt is the currently used time step size.
+         This function may be overwritten.
+     """
          pass
      def writeXML(self, ostream=stdout):
-Line 562 
 class Model(ParameterSet):
+Line 734 
 class Model(ParameterSet):
          self.toDom(document, node)
          ostream.write(document.toprettyxml())
  class Simulation(Model):
      """
-           A Simulation object is special Model which runs a sequence of Models.
+     A Simulation object is special Model which runs a sequence of Models.
-           The methods doInitialization,finalize, getSafeTimeStepSize, doStepPreprocessing,
+     The methods C{doInitialization}, C{finalize}, C{getSafeTimeStepSize},
-           terminateIteration, doStepPostprocessing, doFinalization
+     C{doStepPreprocessing}, C{terminateIteration}, C{doStepPostprocessing},
-           are executing the corresponding methods of the models in the simulation.
+     C{doFinalization} are executing the corresponding methods of the models in
+     the simulation.
      """
      FAILED_TIME_STEPS_MAX=20
      MAX_ITER_STEPS=50
+     MAX_CHANGE_OF_DT=2.
      def __init__(self, models=[], **kwargs):
-         """initiates a simulation from a list of models. """
+         """
+     Initiates a simulation from a list of models.
+     """
          Model.__init__(self, **kwargs)
          self.__models=[]
          for i in range(len(models)):
              self[i] = models[i]
      def __repr__(self):
          """
-         returns a string representation of the Simulation
+         Returns a string representation of the Simulation.
          """
          return "<Simulation %r>" % self.__models
      def __str__(self):
          """
-         returning Simulation as a string
+         Returning Simulation as a string.
          """
          return "<Simulation %d>"%id(self)
      def iterModels(self):
-         """returns an iterator over the models"""
+         """
+     Returns an iterator over the models.
+     """
          return self.__models
      def __getitem__(self,i):
-         """returns the i-th model"""
+         """
+     Returns the i-th model.
+     """
          return self.__models[i]
      def __setitem__(self,i,value):
-         """sets the i-th model"""
+         """
+     Sets the i-th model.
+     """
          if not isinstance(value,Model):
-             raise ValueError("assigned value is not a Model")
+             raise ValueError,"assigned value is not a Model but instance of %s"%(value.__class__.__name__,)
-         for j in range(max(i-len(self.__models)+1,0)): self.__models.append(None)
+         for j in range(max(i-len(self.__models)+1,0)):
+             self.__models.append(None)
          self.__models[i]=value
      def __len__(self):
-         """returns the number of models"""
+         """
+     Returns the number of models.
+     """
          return len(self.__models)
      def toDom(self, document, node):
-         """ toDom method of Simulation class """
+         """
+     C{toDom} method of Simulation class.
+     """
          simulation = document.createElement('Simulation')
          simulation.setAttribute('type', self.__class__.__name__)
-Line 632 
 class Simulation(Model):
+Line 818 
 class Simulation(Model):
          node.appendChild(simulation)
      def writeXML(self,ostream=stdout):
-         """writes the object as an XML object into an output stream"""
+         """
+     Writes the object as an XML object into an output stream.
+     """
          document, rootnode = esysDoc()
          self.toDom(document, rootnode)
+         targetsList = document.getElementsByTagName('Target')
+         for element in targetsList:
+             targetId = int(element.firstChild.nodeValue.strip())
+             if document.getElementById(str(targetId)):
+                 continue
+             targetObj = LinkableObjectRegistry[targetId]
+             targetObj.toDom(document, rootnode)
          ostream.write(document.toprettyxml())
      def getSafeTimeStepSize(self,dt):
-         """returns a time step size which can safely be used by all models.
+         """
-            This is the minimum over the time step sizes of all models."""
+     Returns a time step size which can safely be used by all models.
+         This is the minimum over the time step sizes of all models.
+     """
          out=min([o.getSafeTimeStepSize(dt) for o in self.iterModels()])
-         print "%s: safe step size is %e."%(str(self),out)
+         #print "%s: safe step size is %e."%(str(self),out)
          return out
      def doInitialization(self):
-         """initializes all models """
+         """
+     Initializes all models.
+     """
          self.n=0
          self.tn=0.
          for o in self.iterModels():
              o.doInitialization()
      def finalize(self):
-         """returns True if any of the models is to be finalized"""
+         """
+     Returns True if any of the models is to be finalized.
+     """
          return any([o.finalize() for o in self.iterModels()])
      def doFinalization(self):
-         """finalalizes the time stepping for all models."""
+         """
+     Finalalizes the time stepping for all models.
+     """
          for i in self.iterModels(): i.doFinalization()
          self.trace("end of time integation.")
      def doStepPreprocessing(self,dt):
-         """initializes the time step for all models."""
+         """
+     Initializes the time step for all models.
+     """
          for o in self.iterModels():
              o.doStepPreprocessing(dt)
      def terminateIteration(self):
-         """returns True if all iterations for all models are terminated."""
+         """
+     Returns True if all iterations for all models are terminated.
+     """
          out=all([o.terminateIteration() for o in self.iterModels()])
          return out
      def doStepPostprocessing(self,dt):
-         """finalalizes the iteration process for all models."""
+         """
+     Finalalizes the iteration process for all models.
+     """
          for o in self.iterModels():
              o.doStepPostprocessing(dt)
          self.n+=1
-Line 679 
 class Simulation(Model):
+Line 890 
 class Simulation(Model):
      def doStep(self,dt):
          """
-              executes the iteration step at a time step for all model:
+     Executes the iteration step at a time step for all model::
-                   self.doStepPreprocessing(dt)
+             self.doStepPreprocessing(dt)
-                   while not self.terminateIteration(): for all models: self.doStep(dt)
+             while not self.terminateIteration():
-                   self.doStepPostprocessing(dt)
+             for all models:
+             self.doStep(dt)
+                 self.doStepPostprocessing(dt)
          """
          self.iter=0
          while not self.terminateIteration():
-Line 697 
 class Simulation(Model):
+Line 909 
 class Simulation(Model):
      def run(self,check_point=None):
          """
+     Run the simulation by performing essentially::
-            run the simulation by performing essentially
-                self.doInitialization()
+         self.doInitialization()
-                while not self.finalize():
+         while not self.finalize():
-                   dt=self.getSafeTimeStepSize()
+             dt=self.getSafeTimeStepSize()
-                   self.doStep(dt)
+             self.doStep(dt)
-                   if n%check_point==0: self.writeXML()
+             if n%check_point==0:
-                self.doFinalization()
+             self.writeXML()
+         self.doFinalization()
-            If one of the models in throws a FailedTimeStepError exception a new time step size is
-            computed through getSafeTimeStepSize() and the time step is repeated.
+         If one of the models in throws a C{FailedTimeStepError} exception a
+     new time step size is computed through getSafeTimeStepSize() and the
+     time step is repeated.
-            If one of the models in throws a IterationDivergenceError exception the time step size
+         If one of the models in throws a C{IterationDivergenceError}
-            is halved and the time step is repeated.
+     exception the time step size is halved and the time step is repeated.
-            In both cases the time integration is given up after Simulation.FAILED_TIME_STEPS_MAX
-            attempts.
+         In both cases the time integration is given up after
+     C{Simulation.FAILED_TIME_STEPS_MAX} attempts.
          """
          dt=self.UNDEF_DT
          self.doInitialization()
          while not self.finalize():
              step_fail_counter=0
              iteration_fail_counter=0
-             dt_new=self.getSafeTimeStepSize(dt)
+             if self.n==0:
+                 dt_new=self.getSafeTimeStepSize(dt)
+             else:
+                 dt_new=min(max(self.getSafeTimeStepSize(dt),dt/self.MAX_CHANGE_OF_DT),dt*self.MAX_CHANGE_OF_DT)
              self.trace("%d. time step %e (step size %e.)" % (self.n+1,self.tn+dt_new,dt_new))
              end_of_step=False
              while not end_of_step:
                 end_of_step=True
                 if not dt_new>0:
-                   raise NonPositiveStepSizeError("non-positive step size in step %d",self.n+1)
+                   raise NonPositiveStepSizeError("non-positive step size in step %d"%(self.n+1))
                 try:
                    self.doStepPreprocessing(dt_new)
                    self.doStep(dt_new)
-Line 739 
 class Simulation(Model):
+Line 953 
 class Simulation(Model):
                    end_of_step=False
                    iteration_fail_counter+=1
                    if iteration_fail_counter>self.FAILED_TIME_STEPS_MAX:
-                            raise SimulationBreakDownError("reduction of time step to achieve convergence failed.")
+                            raise SimulationBreakDownError("reduction of time step to achieve convergence failed after %s steps."%self.FAILED_TIME_STEPS_MAX)
-                   self.trace("iteration fails. time step is repeated with new step size.")
+                   self.trace("Iteration failed. Time step is repeated with new step size %s."%dt_new)
                 except FailedTimeStepError:
                    dt_new=self.getSafeTimeStepSize(dt)
                    end_of_step=False
                    step_fail_counter+=1
-                   self.trace("time step is repeated.")
+                   self.trace("Time step is repeated with new time step size %s."%dt_new)
                    if step_fail_counter>self.FAILED_TIME_STEPS_MAX:
-                         raise SimulationBreakDownError("time integration is given up after %d attempts."%step_fail_counter)
+                         raise SimulationBreakDownError("Time integration is given up after %d attempts."%step_fail_counter)
              dt=dt_new
              if not check_point==None:
                  if n%check_point==0:
-Line 770 
 class Simulation(Model):
+Line 984 
 class Simulation(Model):
  class IterationDivergenceError(Exception):
      """
-        excpetion which is thrown if there is no convergence of the iteration process at a time step
+     Exception which is thrown if there is no convergence of the iteration
-        but there is a chance taht a smaller step could help to reach convergence.
+     process at a time step.
+     But there is a chance that a smaller step could help to reach convergence.
      """
      pass
  class FailedTimeStepError(Exception):
-     """excpetion which is thrown if the time step fails because of a step size that have been choosen to be too large"""
+     """
+     Exception which is thrown if the time step fails because of a step
+     size that have been choosen to be too large.
+     """
      pass
  class SimulationBreakDownError(Exception):
-     """excpetion which is thrown if the simulation does not manage to progress in time."""
+     """
+     Exception which is thrown if the simulation does not manage to
+     progress in time.
+     """
      pass
  class NonPositiveStepSizeError(Exception):
-     """excpetion which is thrown if the step size is not positive"""
+     """
+     Exception which is thrown if the step size is not positive.
+     """
      pass
+ class DataSource(object):
+     """
+     Class for handling data sources, including local and remote files. This class is under development.
+     """
+     def __init__(self, uri="file.ext", fileformat="unknown"):
+         self.uri = uri
+         self.fileformat = fileformat
+     def toDom(self, document, node):
+         """
+         C{toDom} method of DataSource. Creates a DataSource node and appends it to the
+     current XML document.
+         """
+         ds = document.createElement('DataSource')
+         ds.appendChild(dataNode(document, 'URI', self.uri))
+         ds.appendChild(dataNode(document, 'FileFormat', self.fileformat))
+         node.appendChild(ds)
+     def fromDom(cls, doc):
+         uri= doc.getElementsByTagName("URI")[0].firstChild.nodeValue.strip()
+         fileformat= doc.getElementsByTagName("FileFormat")[0].firstChild.nodeValue.strip()
+         ds = cls(uri, fileformat)
+         return ds
+     def getLocalFileName(self):
+         return self.uri
+     fromDom = classmethod(fromDom)
+ # vim: expandtab shiftwidth=4:

 Legend:



Removed from v.147
 


changed lines


 
Added in v.885
 Legend:



Removed from v.147
 


changed lines


 
Added in v.885
-Removed from v.147
+Added in v.885

	ViewVC Help
Powered by ViewVC 1.1.26