| 1 |
# $Id$ |
# $Id$ |
|
from types import StringType |
|
| 2 |
|
|
| 3 |
class Link: |
from types import StringType,IntType,FloatType,BooleanType,ListType,DictType |
| 4 |
""" """ |
from sys import stdout |
|
def __init__(self,object,attribute=None): |
|
|
self.__object=object |
|
|
self.setAttributeName(attribute) |
|
|
|
|
|
def setAttributeName(self,name): |
|
|
if not name==None: |
|
|
if not hasattr(self.__object,name): |
|
|
raise AttributeError("Link: object %s has no attribute %s."%(self.__object,name)) |
|
|
self.__attribute=name |
|
|
|
|
|
def hasAttributeName(self): |
|
|
if self.__attribute==None: |
|
|
return False |
|
|
else: |
|
|
return True |
|
|
|
|
|
def __str__(self): |
|
|
if self.hasAttributeName(): |
|
|
return "reference to %s of %s"%(self.__attribute,self.__object) |
|
|
else: |
|
|
return "reference to object %s"%self.__object |
|
|
|
|
|
def getValue(self,name=None): |
|
|
if not self.hasAttributeName(): |
|
|
out=getattr(self.__object,name) |
|
|
else: |
|
|
out=getattr(self.__object,self.__attribute) |
|
|
if callable(out): |
|
|
return out() |
|
|
else: |
|
|
return out |
|
|
|
|
|
class Model: |
|
|
""" 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: |
|
| 5 |
|
|
| 6 |
1) use object attributes: |
from xml.dom import minidom |
| 7 |
|
|
| 8 |
m.message="Hello World!" |
_HEADER_START="<?xml version=\"1.0\"?><ESyS>\n" |
| 9 |
|
_HEADER_END="<\ESyS>\n" |
| 10 |
|
|
| 11 |
2) use setParamter method |
def dataNode(document, tagName, data): |
| 12 |
|
t = document.createTextNode(str(data)) |
| 13 |
|
n = document.createElement(tagName) |
| 14 |
m.setParameters(message="Hello World!") |
n.appendChild(t) |
| 15 |
|
return n |
| 16 |
|
|
| 17 |
|
def esysDoc(): |
| 18 |
|
doc = minidom.Document() |
| 19 |
|
esys = doc.createElement('ESys') |
| 20 |
|
doc.appendChild(esys) |
| 21 |
|
return doc, esys |
| 22 |
|
|
| 23 |
3) or dictonaries |
class Link: |
| 24 |
|
""" |
| 25 |
d={ message : "Hello World!" } |
a Link makes an attribute of an object callable: |
| 26 |
m.setParameters(**d) |
o.object() |
| 27 |
|
o.a=8 |
| 28 |
|
l=Link(o,"a") |
| 29 |
A model executed buy staring the run method of the model: |
assert l()==8 |
| 30 |
|
""" |
| 31 |
m=Messenger() |
|
| 32 |
m.run() |
def __init__(self,target=None,attribute=None): |
| 33 |
|
"""creates a link to the object target. If attribute is given, the link is |
| 34 |
The run methods marches through time. It first calls the |
establised to this attribute of the target. Otherwise the attribute is |
| 35 |
doInitialization() method of the Model to set up the process. In each time step the doStep() method is called |
undefined.""" |
| 36 |
to get from the current to the next time step. The step size is defined by calling the getSafeTimeStepSize() method. |
self.__target=target |
| 37 |
The time integration process is terminated when the finalize() methods return true. Final the doFinalization() method |
self.setAttributeName(attribute) |
| 38 |
is called to finalize the process. To implement a particular model a subclass |
|
| 39 |
of the Model class is defined. The subclass overwrites the default methods of Model. |
def setAttributeName(self,name): |
| 40 |
|
"""set a new attribute name to be collected from the target object. The |
| 41 |
The following class defines a messenger printing in the doStep method what ever the current value of its parameter message is: |
target object must have the attribute with name name.""" |
| 42 |
|
if not name==None: |
| 43 |
class Messenger(Model): |
if not hasattr(self.__target,name): |
| 44 |
def __init__(self): |
raise AttributeError("%s: target %s has no attribute %s."%(self,self.__target,name)) |
| 45 |
Model.__init__(self,parameters={"message" : "none" }) |
self.__attribute=name |
| 46 |
|
|
| 47 |
def doInitialization(self): |
def hasDefinedAttributeName(self): |
| 48 |
print "I start talking now!" |
"""returns true if an attribute name is set""" |
| 49 |
|
if self.__attribute==None: |
| 50 |
def doStep(self,t): |
return False |
| 51 |
print "Message (time %e) : %s "%(t,self.message) |
else: |
| 52 |
|
return True |
| 53 |
def doFinalization(self): |
|
| 54 |
print "I have no more to say!" |
def __str__(self): |
| 55 |
|
"""returns a string representation of the link""" |
| 56 |
If a instance of the Messenger class is run, it will print the initialization and finalization message only. |
if self.hasDefinedAttributeName(): |
| 57 |
This is because the default method for finalize() does always returns True and therefore the transition is |
return "reference to attribute %s of %s"%(self.__attribute,self.__target) |
| 58 |
terminated startcht away. |
else: |
| 59 |
|
return "reference to target %s"%self.__target |
| 60 |
Following example for solving the ODE using a forward euler scheme: |
|
| 61 |
|
def __call__(self,name=None): |
| 62 |
u(t=0)=u0 |
"""returns the value of the attribute of the target object. If the |
| 63 |
u_t=a*u**2 for all 0<t<=ten |
atrribute is callable then the return value of the call is returned.""" |
| 64 |
|
if not name == None: |
| 65 |
exact solution is given by u(t)=1/(1/u0-a*t) |
out=getattr(self.__target, name) |
| 66 |
|
else: |
| 67 |
class Ode1(Model): |
out=getattr(self.__target, self.__attribute) |
| 68 |
def __init__(self,**args): |
if callable(out): |
| 69 |
Model.__init__(self,parameters={"tend" : 1., "dt" : 0.0001 ,"a" : 0.1 ,"u" : 1. },name="test",debug=True) |
return out() |
| 70 |
|
else: |
| 71 |
def doInitialization(self): |
return out |
| 72 |
self._tn=0 |
|
| 73 |
|
def toDom(self, document, node): |
| 74 |
def doStep(self,t): |
""" toDom method of Link. Creates a Link node and appends it to the current XML |
| 75 |
self.u=self.u+(t-self._tn)*self.a*self.u**2 |
document """ |
| 76 |
self._tn=t |
link = document.createElement('link') |
| 77 |
|
link.appendChild(dataNode(document, 'target', id(self.__target))) |
| 78 |
def doFinalization(self): |
link.appendChild(dataNode(document, 'attribute', self.__attribute)) |
| 79 |
print "all done final error = ",abs(self.u-1./(1./3.-self.a*self._tn)) |
node.appendChild(link) |
| 80 |
|
|
| 81 |
def getSafeTimeStepSize(self): |
def writeXML(self,ostream=stdout): |
| 82 |
return self.dt |
"""writes an XML representation of self to the output stream ostream. |
| 83 |
|
If ostream is nor present the standart output stream is used. If |
| 84 |
def finalize(self): |
esysheader==True the esys XML header is written""" |
| 85 |
return self._tn>=self.tend |
|
| 86 |
|
document, rootnode = esysDoc() |
| 87 |
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. ` |
self.toDom(document, rootnode) |
| 88 |
In this case the doStep() method is replaced by a sequance of methods which implements this iterative process. |
|
| 89 |
The method then will control the iteration process by initializing the iteration through calling the |
ostream.write(document.toprettyxml()) |
| 90 |
doIterationInitialization() method. The iteration is preformed by calling the doIterationStep() method until |
|
| 91 |
the terminate() method returns True. The doIterationFinalization() method is called to end the iteration. |
class LinkableObject(object): |
| 92 |
For a particular model these methods have to overwritten by a suitable subclass without touching the doStep() method. |
"""an object that allows to link its attributes to attributes of other |
| 93 |
|
objects via a Link object. For instance |
| 94 |
following example is a modification of the example above. Here an implicit euler scheme is used. in each time step the problem |
|
| 95 |
|
p=LinkableObject() |
| 96 |
0= u_{n+1}-u_{n}+a*dt*u_{n+1}**2 |
p.x=Link(o,"name") |
| 97 |
|
print p.x |
| 98 |
has to be solved for u_{n+1}. The Newton scheme is used to solve this non-linear problem. |
|
| 99 |
|
links attribute x of p to the attribute name of object o. p.x will print |
| 100 |
|
the current value of attribute name of object o. if the value is |
| 101 |
class Ode2(Model): |
callable p.x will rturn the return value of the call. |
| 102 |
|
""" |
| 103 |
|
|
| 104 |
|
def __init__(self,debug=False): |
| 105 |
|
"""initiates a model from a list of subsimulations. """ |
| 106 |
|
self.setDebug(debug) |
| 107 |
|
self.__linked_attributes={} |
| 108 |
|
# |
| 109 |
|
# some basic fuctions: |
| 110 |
|
# |
| 111 |
|
def debugOn(self): |
| 112 |
|
"""sets debugging to on""" |
| 113 |
|
self.__debug=True |
| 114 |
|
def debugOff(self): |
| 115 |
|
"""sets debugging to off""" |
| 116 |
|
self.__debug=False |
| 117 |
|
def debug(self): |
| 118 |
|
"""returns True if debug mode is set to on""" |
| 119 |
|
return self.__debug |
| 120 |
|
def setDebug(self,flag=False): |
| 121 |
|
"""sets debugging to flag""" |
| 122 |
|
if flag: |
| 123 |
|
self.debugOn() |
| 124 |
|
else: |
| 125 |
|
self.debugOff() |
| 126 |
|
|
| 127 |
|
def trace(self, msg): |
| 128 |
|
if self.__debug: |
| 129 |
|
print msg |
| 130 |
|
|
| 131 |
|
def __getattr__(self,name): |
| 132 |
|
"""returns the value of attribute name. If the value is a Link object the |
| 133 |
|
object is called and the return value is returned.""" |
| 134 |
|
out=self.getAttributeObject(name) |
| 135 |
|
if isinstance(out,Link): |
| 136 |
|
return out() |
| 137 |
|
else: |
| 138 |
|
return out |
| 139 |
|
|
| 140 |
|
def getAttributeObject(self,name): |
| 141 |
|
"""return the object stored for attribute name.""" |
| 142 |
|
if self.__dict__.has_key(name): |
| 143 |
|
out=self.__dict__[name] |
| 144 |
|
elif self.__linked_attributes.has_key(name): |
| 145 |
|
out=self.__linked_attributes[name] |
| 146 |
|
else: |
| 147 |
|
raise AttributeError,"No attribute %s."%name |
| 148 |
|
return out |
| 149 |
|
|
| 150 |
|
def __setattr__(self,name,value): |
| 151 |
|
"""sets the value for attribute name. If value is a Link the target |
| 152 |
|
attribute is set to name if no attribute has been specified.""" |
| 153 |
|
if self.__dict__.has_key(name): |
| 154 |
|
del self.__dict__[name] |
| 155 |
|
if isinstance(value,Link): |
| 156 |
|
if not value.hasDefinedAttributeName(): |
| 157 |
|
value.setAttributeName(name) |
| 158 |
|
self.__linked_attributes[name]=value |
| 159 |
|
if self.debug(): |
| 160 |
|
print "DEBUG: %s: attribute %s is now linked by %s."%(self,name,value) |
| 161 |
|
else: |
| 162 |
|
self.__dict__[name]=value |
| 163 |
|
|
| 164 |
|
def __delattr__(self,name): |
| 165 |
|
"""removes the attribute name.""" |
| 166 |
|
if self.__linked_attributes.has_key[name]: |
| 167 |
|
del self.__linked_attributes[name] |
| 168 |
|
elif self.__dict__.has_key(name): |
| 169 |
|
del self.__dict__[name] |
| 170 |
|
else: |
| 171 |
|
raise AttributeError,"No attribute %s."%name |
| 172 |
|
|
| 173 |
|
class SimulationFrame(LinkableObject): |
| 174 |
|
"""A SimulationFrame objects represents a processess marching over time |
| 175 |
|
until a finalizing condition is fullfilled. At each time step an iterative |
| 176 |
|
process can be performed and the time step size can be controlled |
| 177 |
|
""" |
| 178 |
|
UNDEF_DT=1.e300 |
| 179 |
|
MAX_TIME_STEP_REDUCTION=20 |
| 180 |
|
MAX_ITER_STEPS=50 |
| 181 |
|
|
| 182 |
|
def __init__(self,debug=False): |
| 183 |
|
"""initiates a simulation""" |
| 184 |
|
LinkableObject.__init__(self,debug) |
| 185 |
|
|
| 186 |
|
def doInitialization(self,t): |
| 187 |
|
"""initializes the time stepping scheme. This function may be |
| 188 |
|
overwritten.""" |
| 189 |
|
pass |
| 190 |
|
|
| 191 |
|
def getSafeTimeStepSize(self,dt): |
| 192 |
|
"""returns a time step size which can savely be used. This function may |
| 193 |
|
be overwritten.""" |
| 194 |
|
return self.UNDEF_DT |
| 195 |
|
|
| 196 |
|
def finalize(self): |
| 197 |
|
"""returns True if the time stepping is finalized. This function may be |
| 198 |
|
overwritten.""" |
| 199 |
|
return True |
| 200 |
|
|
| 201 |
|
def doFinalization(self): |
| 202 |
|
"""finalizes the time stepping. This function may be overwritten.""" |
| 203 |
|
pass |
| 204 |
|
|
| 205 |
|
def doIterationInitialization(self,dt): |
| 206 |
|
"""initializes the iteration at time step t. This function may be |
| 207 |
|
overwritten. (only called if doStep is not overwritten)""" |
| 208 |
|
pass |
| 209 |
|
|
| 210 |
|
def doIterationStep(self,dt): |
| 211 |
|
"""executes the iteration step. This function may be overwritten. (only |
| 212 |
|
called if doStep is not overwritten)""" |
| 213 |
|
pass |
| 214 |
|
|
| 215 |
|
def terminate(self): |
| 216 |
|
"""returns True if iteration on a time step is terminated. (only called |
| 217 |
|
if doStep is not overwritten)""" |
| 218 |
|
return True |
| 219 |
|
|
| 220 |
|
def doIterationFinalization(self,dt): |
| 221 |
|
"""finalalizes the iteration process. (only called if doStep is not |
| 222 |
|
overwritten)""" |
| 223 |
|
pass |
| 224 |
|
|
| 225 |
|
def run(self,check_point=None): |
| 226 |
|
"""run the simulation by performing essentially |
| 227 |
|
|
| 228 |
|
self.doInitialization() |
| 229 |
|
while not self.finalize(): |
| 230 |
|
dt=self.getSafeTimeStepSize() |
| 231 |
|
self.doStep(dt) |
| 232 |
|
if n%check_point==0: self.writeXML() |
| 233 |
|
self.doFinalization() |
| 234 |
|
|
| 235 |
|
""" |
| 236 |
|
self.__tn=0. |
| 237 |
|
self.__n=0 |
| 238 |
|
self.__dt=None |
| 239 |
|
self.doInitialization(self.__tn) |
| 240 |
|
while not self.finalize(): |
| 241 |
|
self.__n+=1 |
| 242 |
|
self.__dt=self.getSafeTimeStepSize(self.__dt) |
| 243 |
|
if self.__dt==None: self.__dt=self.UNDEF_DT |
| 244 |
|
if not self.__dt>0: |
| 245 |
|
raise NonPositiveStepSizeError("non-positive step size in step %d",self.__n) |
| 246 |
|
if self.debug(): print "%s: %d. time step %e (step size %e.)"%(self,self.__n,self.__tn+self.__dt,self.__dt) |
| 247 |
|
endoftimestep=False |
| 248 |
|
failcounter=0 |
| 249 |
|
while not endoftimestep: |
| 250 |
|
endoftimestep=True |
| 251 |
|
try: |
| 252 |
|
self.doStep(self.__dt) |
| 253 |
|
except FailedTimeStepError: |
| 254 |
|
self.__dt=self.getSafeTimeStepSize(self.__dt) |
| 255 |
|
if self.__dt==None: self.__dt=self.UNDEF_DT |
| 256 |
|
endoftimestep=False |
| 257 |
|
if self.debug(): print "%s: time step is repeated with new step size %e."%(self,self.__dt) |
| 258 |
|
except IterationDivergenceError: |
| 259 |
|
self.__dt*=0.5 |
| 260 |
|
endoftimestep=False |
| 261 |
|
failcounter+=1 |
| 262 |
|
if failcounter>self.MAX_TIME_STEP_REDUCTION: |
| 263 |
|
raise IterationBreakDownError("reduction of time step to achieve convergence failed.") |
| 264 |
|
|
| 265 |
|
self.trace("%s: iteration failes. time step is repeated with new step size %e." |
| 266 |
|
% (self,self.__dt)) |
| 267 |
|
self.__tn+=self.__dt |
| 268 |
|
if not check_point==None: |
| 269 |
|
if self.__n%check_point==0: |
| 270 |
|
self.trace("%s: check point is created."%self) |
| 271 |
|
self.writeXML() |
| 272 |
|
self.doFinalization() |
| 273 |
|
|
| 274 |
|
def writeXML(self): |
| 275 |
|
raise RuntimeError, "Not implemented" |
| 276 |
|
|
| 277 |
|
def doStep(self,dt): |
| 278 |
|
"""executes a time step by iteration. This function may be overwritten. |
| 279 |
|
|
| 280 |
|
basicly it performs : |
| 281 |
|
|
| 282 |
|
self.doIterationInitialization(dt) |
| 283 |
|
while not self.terminate(): self.doIterationStep(dt) |
| 284 |
|
self.doIterationFinalization(dt) |
| 285 |
|
|
| 286 |
|
""" |
| 287 |
|
self.doIterationInitialization(dt) |
| 288 |
|
self.__iter=0 |
| 289 |
|
while not self.terminate(): |
| 290 |
|
if self.debug(): print "%s: iteration step %d"%(self,self.__iter) |
| 291 |
|
self.doIterationStep(dt) |
| 292 |
|
self.__iter+=1 |
| 293 |
|
if self.__iter>self.MAX_ITER_STEPS: |
| 294 |
|
raise IterationDivergenceError("%s: divergence in step %d"%(self,self.__iter)) |
| 295 |
|
self.doIterationFinalization(dt) |
| 296 |
|
|
| 297 |
|
class Simulation(SimulationFrame): |
| 298 |
|
"""A Simulation object is comprised by SimulationFrame(s) called subsimulations.""" |
| 299 |
|
|
| 300 |
|
def __init__(self,subsimulations=[],debug=False): |
| 301 |
|
"""initiates a simulation from a list of subsimulations. """ |
| 302 |
|
SimulationFrame.__init__(self,debug) |
| 303 |
|
self.__subsimulations=[] |
| 304 |
|
for i in range(len(subsimulations)): self[i]=subsimulations[i] |
| 305 |
|
|
| 306 |
|
def iterSubsimulations(self): |
| 307 |
|
"""returns an iterator over the subsimulations""" |
| 308 |
|
return self.__subsimulations |
| 309 |
|
|
| 310 |
|
def __getitem__(self,i): |
| 311 |
|
"""returns the i-th subsimulation""" |
| 312 |
|
return self.__subsimulations[i] |
| 313 |
|
|
| 314 |
|
def __setitem__(self,i,value): |
| 315 |
|
"""sets the i-th subsimulation""" |
| 316 |
|
if not isinstance(value,SimulationFrame): |
| 317 |
|
raise ValueError("assigned value is not a Simulation") |
| 318 |
|
for j in range(max(i-len(self.__subsimulations)+1,0)): self.__subsimulations.append(None) |
| 319 |
|
self.__subsimulations[i]=value |
| 320 |
|
|
| 321 |
|
def __len__(self): |
| 322 |
|
"""returns the number of subsimulations""" |
| 323 |
|
return len(self.__subsimulations) |
| 324 |
|
|
| 325 |
|
def toDom(self, document, node): |
| 326 |
|
""" toDom method of Simualtion class """ |
| 327 |
|
simulation = document.createElement('Simulation') |
| 328 |
|
simulation.setAttribute('type', self.__class__.__name__) |
| 329 |
|
|
| 330 |
|
for rank, sim in enumerate(self.iterSubsimulations()): |
| 331 |
|
component = document.createElement('Component') |
| 332 |
|
component.setAttribute('rank', str(rank)) |
| 333 |
|
|
| 334 |
|
sim.toDom(document, component) |
| 335 |
|
|
| 336 |
|
simulation.appendChild(component) |
| 337 |
|
|
| 338 |
|
node.appendChild(simulation) |
| 339 |
|
|
| 340 |
|
def writeXML(self,ostream=stdout): |
| 341 |
|
"""writes the object as an XML object into an output stream""" |
| 342 |
|
document, rootnode = esysDoc() |
| 343 |
|
self.toDom(document, rootnode) |
| 344 |
|
ostream.write(document.toprettyxml()) |
| 345 |
|
|
| 346 |
|
def getSafeTimeStepSize(self,dt): |
| 347 |
|
"""returns a time step size which can savely be used by all subsimulations""" |
| 348 |
|
out=self.UNDEF_DT |
| 349 |
|
for i in self.iterSubsimulations(): |
| 350 |
|
dt_new=i.getSafeTimeStepSize(dt) |
| 351 |
|
if dt_new!=None: out=min(out,dt_new) |
| 352 |
|
return out |
| 353 |
|
|
| 354 |
|
def doInitialization(self,dt): |
| 355 |
|
"""initializes all subsimulations """ |
| 356 |
|
for i in self.iterSubsimulations(): i.doInitialization(dt) |
| 357 |
|
|
| 358 |
|
def finalize(self): |
| 359 |
|
"""returns True if all subsimulations are finalized""" |
| 360 |
|
out=True |
| 361 |
|
for i in self.iterSubsimulations(): out = out and i.finalize() |
| 362 |
|
return out |
| 363 |
|
|
| 364 |
|
def doFinalization(self): |
| 365 |
|
"""finalalizes the time stepping for all subsimulations.""" |
| 366 |
|
for i in self.iterSubsimulations(): i.doFinalization() |
| 367 |
|
|
| 368 |
|
def doIterationInitialization(self,dt): |
| 369 |
|
"""initializes the iteration at time t for all subsimulations.""" |
| 370 |
|
self.__iter=0 |
| 371 |
|
if self.debug(): print "%s: iteration starts"%self |
| 372 |
|
for i in self.iterSubsimulations(): i.doIterationInitialization(dt) |
| 373 |
|
|
| 374 |
|
def terminate(self): |
| 375 |
|
"""returns True if all iterations for all subsimulations are terminated.""" |
| 376 |
|
out=True |
| 377 |
|
for i in self.iterSubsimulations(): out = out and i.terminate() |
| 378 |
|
return out |
| 379 |
|
|
| 380 |
|
def doIterationFinalization(self,dt): |
| 381 |
|
"""finalalizes the iteration process for each of the subsimulations.""" |
| 382 |
|
for i in self.iterSubsimulations(): i.doIterationFinalization(dt) |
| 383 |
|
if self.debug(): print "%s: iteration finalized after %s steps"%(self,self.__iter+1) |
| 384 |
|
|
| 385 |
|
def doIterationStep(self,dt): |
| 386 |
|
"""executes the iteration step at time step for each subsimulation""" |
| 387 |
|
self.__iter+=1 |
| 388 |
|
if self.debug(): print "%s: iteration step %d"%(self,self.__iter) |
| 389 |
|
for i in self.iterSubsimulations(): i.doIterationStep(dt) |
| 390 |
|
|
| 391 |
|
class ExplicitSimulation(Simulation): |
| 392 |
|
"""This is a modified form of the Simulation class. In fact it overwrites |
| 393 |
|
the doStep method by executing the doStep method of all subsimulations |
| 394 |
|
rather then iterating over all subsimulations.""" |
| 395 |
|
|
| 396 |
|
def doStep(self,dt): |
| 397 |
|
"""executes the time step for all subsimulation""" |
| 398 |
|
for i in self.iterSubsimulations(): i.doStep(dt) |
| 399 |
|
|
| 400 |
|
class _ParameterIterator: |
| 401 |
|
def __init__(self,parameterset): |
| 402 |
|
self.__set=parameterset |
| 403 |
|
self.__iter=iter(parameterset.getParameterList()) |
| 404 |
|
def next(self): |
| 405 |
|
o=self.__iter.next() |
| 406 |
|
return (o,self.__set.getAttributeObject(o)) |
| 407 |
|
def __iter__(self): |
| 408 |
|
return self |
| 409 |
|
|
| 410 |
|
class ParameterSet(LinkableObject): |
| 411 |
|
"""a class which allows to emphazise attributes to be written and read to XML |
| 412 |
|
|
| 413 |
|
Leaves of an ESySParameters objects can be |
| 414 |
|
|
| 415 |
|
a real number |
| 416 |
|
a integer number |
| 417 |
|
a string |
| 418 |
|
a boolean value |
| 419 |
|
a ParameterSet object |
| 420 |
|
a Simulation object |
| 421 |
|
a Model object |
| 422 |
|
any other object (not considered by writeESySXML and writeXML) |
| 423 |
|
|
| 424 |
|
Example how to create an ESySParameters object: |
| 425 |
|
|
| 426 |
|
p11=ParameterSet(gamma1=1.,gamma2=2.,gamma3=3.) |
| 427 |
|
p1=ParameterSet(dim=2,tol_v=0.001,output_file="/tmp/u.%3.3d.dx",runFlag=True,parm11=p11) |
| 428 |
|
parm=ParameterSet(parm1=p1,parm2=ParameterSet(alpha=Link(p11,"gamma1"))) |
| 429 |
|
|
| 430 |
|
This can be accessed as |
| 431 |
|
|
| 432 |
|
parm.parm1.gamma=0. |
| 433 |
|
parm.parm1.dim=2 |
| 434 |
|
parm.parm1.tol_v=0.001 |
| 435 |
|
parm.parm1.output_file="/tmp/u.%3.3d.dx" |
| 436 |
|
parm.parm1.runFlag=True |
| 437 |
|
parm.parm1.parm11.gamma1=1. |
| 438 |
|
parm.parm1.parm11.gamma2=2. |
| 439 |
|
parm.parm1.parm11.gamma3=3. |
| 440 |
|
parm.parm2.alpha=1. (value of parm.parm1.parm11.gamma1) |
| 441 |
|
|
| 442 |
|
""" |
| 443 |
|
def __init__(self,parameters=[]): |
| 444 |
|
"""creates a ParameterSet with parameters parameters""" |
| 445 |
|
LinkableObject.__init__(self,debug=False) |
| 446 |
|
self.__parameters=[] |
| 447 |
|
self.declareParameters(parameters) |
| 448 |
|
|
| 449 |
|
def getParameterList(self): |
| 450 |
|
"""returns the list of parameters""" |
| 451 |
|
return self.__parameters |
| 452 |
|
|
| 453 |
|
def isParameter(self,name): |
| 454 |
|
"""returns true if name is a parameter""" |
| 455 |
|
return name in self.getParameterList() |
| 456 |
|
|
| 457 |
|
def declareParameter(self,**parameters): |
| 458 |
|
"""declares a new parameter(s) and its (their) inital value.""" |
| 459 |
|
self.declareParameters(parameters) |
| 460 |
|
|
| 461 |
|
def declareParameters(self,parameters): |
| 462 |
|
"""declares a set of parameters. parameters can be a list, a dictonary or a ParameterSet.""" |
| 463 |
|
if isinstance(parameters,ListType): |
| 464 |
|
for prm in parameters: |
| 465 |
|
setattr(self,prm,None) |
| 466 |
|
if not self.isParameter(prm): self.getParameterList().append(prm) |
| 467 |
|
if self.debug(): print "%s: parameter %s has been declared."%(self,prm) |
| 468 |
|
elif isinstance(parameters,DictType): |
| 469 |
|
for prm,value in parameters.iteritems(): |
| 470 |
|
setattr(self,prm,value) |
| 471 |
|
if not self.isParameter(prm): self.getParameterList().append(prm) |
| 472 |
|
if self.debug(): print "%s: parameter %s has been declared."%(self,prm) |
| 473 |
|
else: |
| 474 |
|
for prm,value in parameters: |
| 475 |
|
setattr(self,prm,value) |
| 476 |
|
if not self.isParameter(prm): self.getParameterList().append(prm) |
| 477 |
|
if self.debug(): print "%s: parameter %s has been declared."%(self,prm) |
| 478 |
|
|
| 479 |
|
def releaseParameters(self,name): |
| 480 |
|
"""removes parameter name from the paramameters""" |
| 481 |
|
if self.isParameter(name): |
| 482 |
|
self.getParameterList().remove(name) |
| 483 |
|
if self.debug(): print "%s: parameter %s has been removed."%(self,prm) |
| 484 |
|
|
| 485 |
|
def __iter__(self): |
| 486 |
|
"""creates an iterator over the parameter and their values""" |
| 487 |
|
return _ParameterIterator(self) |
| 488 |
|
|
| 489 |
|
def showParameters(self): |
| 490 |
|
"""returns a descrition of the parameters""" |
| 491 |
|
out="{" |
| 492 |
|
notfirst=False |
| 493 |
|
for i,v in self: |
| 494 |
|
if notfirst: out=out+"," |
| 495 |
|
notfirst=True |
| 496 |
|
if isinstance(v,ParameterSet): |
| 497 |
|
out="%s\"%s\" : %s"%(out,i,v.showParameters()) |
| 498 |
|
else: |
| 499 |
|
out="%s\"%s\" : %s"%(out,i,v) |
| 500 |
|
return out+"}" |
| 501 |
|
|
| 502 |
|
def __delattr__(self,name): |
| 503 |
|
"""removes the attribute name.""" |
| 504 |
|
LinkableObject.__delattr__(self,name) |
| 505 |
|
try: |
| 506 |
|
self.releaseParameter(name) |
| 507 |
|
except: |
| 508 |
|
pass |
| 509 |
|
|
| 510 |
|
def toDom(self, document, node): |
| 511 |
|
""" toDom method of ParameterSet class """ |
| 512 |
|
pset = document.createElement('ParameterSet') |
| 513 |
|
node.appendChild(pset) |
| 514 |
|
self._parametersToDom(document, pset) |
| 515 |
|
|
| 516 |
|
def _parametersToDom(self, document, node): |
| 517 |
|
for name,value in self: |
| 518 |
|
param = document.createElement('Parameter') |
| 519 |
|
param.setAttribute('type', value.__class__.__name__) |
| 520 |
|
|
| 521 |
|
param.appendChild(dataNode(document, 'Name', name)) |
| 522 |
|
|
| 523 |
|
val = document.createElement('Value') |
| 524 |
|
|
| 525 |
|
if isinstance(value,ParameterSet): |
| 526 |
|
value.toDom(document, val) |
| 527 |
|
elif isinstance(value, Link): |
| 528 |
|
value.toDom(document, val) |
| 529 |
|
param.appendChild(val) |
| 530 |
|
elif isinstance(value,StringType): |
| 531 |
|
param.appendChild(dataNode(document, 'Value', value)) |
| 532 |
|
else: |
| 533 |
|
param.appendChild(dataNode(document, 'Value', str(value))) |
| 534 |
|
|
| 535 |
|
node.appendChild(param) |
| 536 |
|
|
| 537 |
|
def writeXML(self,ostream=stdout): |
| 538 |
|
"""writes the object as an XML object into an output stream""" |
| 539 |
|
# ParameterSet(d) with d[Name]=Value |
| 540 |
|
document, node = esysDoc() |
| 541 |
|
self.toDom(document, node) |
| 542 |
|
ostream.write(document.toprettyxml()) |
| 543 |
|
|
| 544 |
|
class Model(ParameterSet,SimulationFrame): |
| 545 |
|
"""a Model is a SimulationFrame which is also a ParameterSet.""" |
| 546 |
|
|
| 547 |
|
def __init__(self,debug=False): |
| 548 |
|
"""creates a model""" |
| 549 |
|
ParameterSet.__init__(self) |
| 550 |
|
SimulationFrame.__init__(self,debug=debug) |
| 551 |
|
|
| 552 |
|
def writeXML(self,ostream=stdout,esysheader=True,modelheader=True): |
| 553 |
|
"""writes the object as an XML object into an output stream""" |
| 554 |
|
# x=type() with x.Name=Value where type is a Model from the model library. |
| 555 |
|
if esysheader: ostream.write(_HEADER_START) |
| 556 |
|
ostream.write("<Model type=\"%s\" module=\"%s\">\n"%(self.__class__.__name__,self.__class__.__module__)) |
| 557 |
|
self. writeParameterXML(ostream) |
| 558 |
|
ostream.write("</Model>\n") |
| 559 |
|
if esysheader: ostream.write(_HEADER_END) |
| 560 |
|
|
| 561 |
def __init__(self,**args): |
class IterationDivergenceError(Exception): |
| 562 |
Model.__init__(self,{"tend" : 1., "dt" : 0.1 ,"a" : 10. ,"u" : 1. , "tol " : 1.e-8},"test","bla",None,True) |
"""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 |
| 563 |
|
to reach convergence.""" |
| 564 |
|
pass |
| 565 |
|
|
| 566 |
|
class IterationBreakDownError(Exception): |
| 567 |
|
"""excpetion which should be thrown if there is no conevregence and there is no chance that a time step reduction would help""" |
| 568 |
|
pass |
| 569 |
|
|
| 570 |
def doInitialization(self): |
class FailedTimeStepError(Exception): |
| 571 |
self.__tn=0 |
"""excpetion which should be thrown if the time step fails because of a step size that have been choosen to be to large""" |
| 572 |
|
pass |
| 573 |
|
|
| 574 |
def doIterationInitialization(self,t): |
class NonPositiveStepSizeError(Exception): |
| 575 |
self.__iter=0 |
"""excpetion which is thrown if the step size is not positive""" |
| 576 |
self.u_last=self.u |
pass |
|
self.current_dt=t-self.tn |
|
|
self.__tn=t |
|
| 577 |
|
|
| 578 |
def doIterationStep(self): |
# |
| 579 |
self.__iter+=1 |
# ignore this text: |
| 580 |
self.u_old=self.u |
# |
| 581 |
self.u=(self.current_dt*self.a*self.u**2-self.u_last)/(2*self.current_dt*self.a*self.u-1.) |
""" the Model class provides a framework to run a time-dependent simulation. A |
| 582 |
|
Model has a set of parameter which may be fixed or altered by the Model itself |
| 583 |
|
or other Models over time. |
| 584 |
|
|
| 585 |
def terminate(self): |
The parameters of a models are declared at instantion, e.g. |
|
return abs(self.u_old-self.u)<self.tol*abs(self.u) |
|
| 586 |
|
|
| 587 |
def doIterationFinalization(self) |
m=Model({"message" : "none" }) |
|
print "all done" |
|
| 588 |
|
|
| 589 |
def getSafeTimeStepSize(self): |
creates a Model with parameters p1 and p2 with inital values 1 and 2. |
| 590 |
return self.dt |
Typically a particular model is defined as a subclass of Model: |
| 591 |
|
|
| 592 |
def finalize(self): |
class Messenger(Model): |
| 593 |
return self.__tn>self.tend |
def __init__(self): |
| 594 |
|
Model.__init__(self,parameters={"message" : "none" }) |
| 595 |
|
|
| 596 |
A model can be composed from submodels. Submodels are treated as model parameters. If a model parameter is set or a value of |
m=MyModel() |
|
a model parameter is requested, the model will search for this parameter its submodels in the case the model does not have this |
|
|
parameter itself. The order in which the submodels are searched is critical. By default a Model initializes all its submodels, |
|
|
is finalized when all its submodels are finalized and finalizes all its submodels. In the case an iterative process is applied |
|
|
on a particular time step the iteration is initialized for all submodels, then the iteration step is performed for each submodel |
|
|
until all submodels indicate termination. Then the iteration is finalized for all submodels. Finally teh doStop() method for all |
|
|
submethods is called. |
|
| 597 |
|
|
| 598 |
Here we are creating a model which groups ab instantiation of the Ode2 and the Messenger Model |
There are various ways how model parameters can be changed: |
| 599 |
|
|
| 600 |
o=Ode2() |
1) use object attributes: |
|
m=Messenger() |
|
|
om=Model(submodels=[o,m],debug=True) |
|
|
om.dt=0.01 |
|
|
om.u=1. |
|
|
m.message="it's me!" |
|
|
om.run() |
|
| 601 |
|
|
| 602 |
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 |
m.message="Hello World!" |
|
automatically hand the assignment of new values down to the submodel. 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. |
|
| 603 |
|
|
| 604 |
A parameter of a Model can be linked to an attribute of onother object, typically an parameter of another Model object. |
2) use setParamter method |
| 605 |
|
|
| 606 |
|
|
| 607 |
which is comprised by a set of submodels. |
m.setParameters(message="Hello World!") |
|
The simulation is run through its run method which in the simplest case has the form: |
|
| 608 |
|
|
| 609 |
s=Model() |
3) or dictonaries |
| 610 |
s.run() |
|
| 611 |
|
d={ message : "Hello World!" } |
| 612 |
|
m.setParameters(**d) |
| 613 |
|
|
|
The run has an initializion and finalization phase. The latter is called if all submodels are to be finalized. The |
|
|
simulation is processing in time through calling the stepForward methods which updates the observables of each submodel. |
|
|
A time steps size which is save for all submodel is choosen. |
|
| 614 |
|
|
| 615 |
At given time step an iterative process may be performed to make sure that all observables are consistent across all submodels. |
A model executed buy staring the run method of the model: |
| 616 |
In this case, similar the time dependence, an initialization and finalization of the iteration is performed. |
|
| 617 |
|
m=Messenger() |
| 618 |
|
m.run() |
| 619 |
|
|
| 620 |
A Model has input and output parameters where each input parameter can be constant, time dependent or may depend on an |
The run methods marches through time. It first calls the |
| 621 |
output parameter of another model or the model itself. To create a parameter name of a model and to |
doInitialization() method of the Model to set up the process. In each |
| 622 |
assign a value to it one can use the statement |
time step the doStep() method is called to get from the current to the |
| 623 |
|
next time step. The step size is defined by calling the |
| 624 |
|
getSafeTimeStepSize() method. the time integration process is |
| 625 |
|
terminated when the finalize() methods return true. Final the |
| 626 |
|
doFinalization() method is called to finalize the process. To implement |
| 627 |
|
a particular model a subclass of the Model class is defined. The |
| 628 |
|
subclass overwrites the default methods of Model. |
| 629 |
|
|
| 630 |
|
The following class defines a messenger printing in the doStep method |
| 631 |
|
what ever the current value of its parameter message is: |
| 632 |
|
|
| 633 |
|
class Messenger(Model): |
| 634 |
|
def __init__(self): |
| 635 |
|
Model.__init__(self,parameters={"message" : "none" }) |
| 636 |
|
|
| 637 |
|
def doInitialization(self): |
| 638 |
|
print "I start talking now!" |
| 639 |
|
|
| 640 |
|
def doStep(self,t): |
| 641 |
|
print "Message (time %e) : %s "%(t,self.message) |
| 642 |
|
|
| 643 |
|
def doFinalization(self): |
| 644 |
|
print "I have no more to say!" |
| 645 |
|
|
| 646 |
|
If a instance of the Messenger class is run, it will print the |
| 647 |
|
initialization and finalization message only. This is because the |
| 648 |
|
default method for finalize() does always returns True and therefore the |
| 649 |
|
transition is terminated startcht away. |
| 650 |
|
|
| 651 |
|
Following example for solving the ODE using a forward euler scheme: |
| 652 |
|
|
| 653 |
|
u(t=0)=u0 |
| 654 |
|
u_t=a*u**2 for all 0<t<=ten |
| 655 |
|
|
| 656 |
|
exact solution is given by u(t)=1/(1/u0-a*t) |
| 657 |
|
|
| 658 |
|
class Ode1(Model): |
| 659 |
|
def __init__(self,**args): |
| 660 |
|
Model.__init__(self,parameters={"tend" : 1., "dt" : 0.0001 ,"a" : 0.1 ,"u" : 1. },name="test",debug=True) |
| 661 |
|
|
| 662 |
|
def doInitialization(self): |
| 663 |
|
self._tn=0 |
| 664 |
|
|
| 665 |
|
def doStep(self,t): |
| 666 |
|
self.u=self.u+(t-self._tn)*self.a*self.u**2 |
| 667 |
|
self._tn=t |
| 668 |
|
|
| 669 |
|
def doFinalization(self): |
| 670 |
|
print "all done final error = ",abs(self.u-1./(1./3.-self.a*self._tn)) |
| 671 |
|
|
| 672 |
|
def getSafeTimeStepSize(self): |
| 673 |
|
return self.dt |
| 674 |
|
|
| 675 |
|
def finalize(self): |
| 676 |
|
return self._tn>=self.tend |
| 677 |
|
|
| 678 |
|
In some cases at a given time step an iteration process has to be |
| 679 |
|
performed to get the state of the Model for the next time step. ` In |
| 680 |
|
this case the doStep() method is replaced by a sequance of methods which |
| 681 |
|
implements this iterative process. The method then will control the |
| 682 |
|
iteration process by initializing the iteration through calling the |
| 683 |
|
doIterationInitialization() method. The iteration is preformed by |
| 684 |
|
calling the doIterationStep() method until the terminate() method |
| 685 |
|
returns True. The doIterationFinalization() method is called to end the |
| 686 |
|
iteration. |
| 687 |
|
For a particular model these methods have to overwritten by a suitable |
| 688 |
|
subclass without touching the doStep() method. |
| 689 |
|
|
| 690 |
|
following example is a modification of the example above. Here an |
| 691 |
|
implicit euler scheme is used. in each time step the problem |
| 692 |
|
|
| 693 |
|
0= u_{n+1}-u_{n}+a*dt*u_{n+1}**2 |
| 694 |
|
|
| 695 |
model.name=object |
has to be solved for u_{n+1}. The Newton scheme is used to solve this non-linear problem. |
| 696 |
|
|
| 697 |
|
|
| 698 |
|
class Ode2(Model): |
| 699 |
|
|
| 700 |
At any time the current value of the parameter name can be obtained by |
def __init__(self,**args): |
| 701 |
|
Model.__init__(self,{"tend" : 1., "dt" : 0.1 ,"a" : 10. ,"u" : 1. , "tol " : 1.e-8},"test","bla",None,True) |
| 702 |
|
|
| 703 |
value=model.name |
def doInitialization(self): |
| 704 |
|
self.__tn=0 |
| 705 |
|
|
| 706 |
If the object that has been assigned to the paramter/attribute name has the attribute/parameter name isself the current value of this |
def doIterationInitialization(self,t): |
| 707 |
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 |
self.__iter=0 |
| 708 |
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 |
self.u_last=self.u |
| 709 |
|
self.current_dt=t-self.tn |
| 710 |
|
self.__tn=t |
| 711 |
|
|
| 712 |
|
def doIterationStep(self): |
| 713 |
|
self.__iter+=1 |
| 714 |
|
self.u_old=self.u |
| 715 |
|
self.u=(self.current_dt*self.a*self.u**2-self.u_last)/(2*self.current_dt*self.a*self.u-1.) |
| 716 |
|
|
| 717 |
|
def terminate(self): |
| 718 |
|
return abs(self.u_old-self.u)<self.tol*abs(self.u) |
| 719 |
|
|
| 720 |
|
def doIterationFinalization(self) |
| 721 |
|
print "all done" |
| 722 |
|
|
| 723 |
|
def getSafeTimeStepSize(self): |
| 724 |
|
return self.dt |
| 725 |
|
|
| 726 |
|
def finalize(self): |
| 727 |
|
return self.__tn>self.tend |
| 728 |
|
|
| 729 |
|
A model can be composed from subsimulations. Subsimulations are treated |
| 730 |
|
as model parameters. If a model parameter is set or a value of a model |
| 731 |
|
parameter is requested, the model will search for this parameter its |
| 732 |
|
subsimulations in the case the model does not have this parameter |
| 733 |
|
itself. The order in which the subsimulations are searched is critical. |
| 734 |
|
By default a Model initializes all its subsimulations, is finalized when |
| 735 |
|
all its subsimulations are finalized and finalizes all its |
| 736 |
|
subsimulations. In the case an iterative process is applied on a |
| 737 |
|
particular time step the iteration is initialized for all |
| 738 |
|
subsimulations, then the iteration step is performed for each |
| 739 |
|
subsimulation until all subsimulations indicate termination. Then the |
| 740 |
|
iteration is finalized for all subsimulations. Finally teh doStop() |
| 741 |
|
method for all submethods is called. |
| 742 |
|
|
| 743 |
|
Here we are creating a model which groups ab instantiation of the Ode2 and the Messenger Model |
| 744 |
|
|
| 745 |
|
o=Ode2() |
| 746 |
|
m=Messenger() |
| 747 |
|
om=Model(subsimulations=[o,m],debug=True) |
| 748 |
|
om.dt=0.01 |
| 749 |
|
om.u=1. |
| 750 |
|
m.message="it's me!" |
| 751 |
|
om.run() |
| 752 |
|
|
| 753 |
|
Notice that dt and u are parameters of class Ode2 and message is a |
| 754 |
|
parameter of the Messenger class. The Model formed from these models |
| 755 |
|
automatically hand the assignment of new values down to the |
| 756 |
|
subsimulation. om.run() starts this combined model where now the |
| 757 |
|
soStep() method of the Messenger object printing the value of its |
| 758 |
|
parameter message together with a time stamp is executed in each time |
| 759 |
|
step introduced by the Ode2 model. |
| 760 |
|
|
| 761 |
|
A parameter of a Model can be linked to an attribute of onother object, |
| 762 |
|
typically an parameter of another Model object. |
| 763 |
|
|
| 764 |
|
|
| 765 |
|
which is comprised by a set of subsimulations. |
| 766 |
|
The simulation is run through its run method which in the simplest case has the form: |
| 767 |
|
|
| 768 |
|
s=Model() |
| 769 |
|
s.run() |
| 770 |
|
|
| 771 |
|
The run has an initializion and finalization phase. The latter is called |
| 772 |
|
if all subsimulations are to be finalized. The simulation is processing |
| 773 |
|
in time through calling the stepForward methods which updates the |
| 774 |
|
observables of each subsimulation. A time steps size which is save for |
| 775 |
|
all subsimulation is choosen. |
| 776 |
|
|
| 777 |
|
At given time step an iterative process may be performed to make sure |
| 778 |
|
that all observables are consistent across all subsimulations. In this |
| 779 |
|
case, similar the time dependence, an initialization and finalization of |
| 780 |
|
the iteration is performed. |
| 781 |
|
|
| 782 |
|
A Model has input and output parameters where each input parameter can |
| 783 |
|
be constant, time dependent or may depend on an output parameter of |
| 784 |
|
another model or the model itself. To create a parameter name of a model |
| 785 |
|
and to assign a value to it one can use the statement |
| 786 |
|
|
| 787 |
|
model.name=object |
| 788 |
|
|
| 789 |
|
|
| 790 |
|
At any time the current value of the parameter name can be obtained by |
| 791 |
|
|
| 792 |
|
value=model.name |
| 793 |
|
|
| 794 |
|
If the object that has been assigned to the paramter/attribute name has |
| 795 |
|
the attribute/parameter name isself the current value of this attribute |
| 796 |
|
of the object is returned (e.g. for model.name=object where object has |
| 797 |
|
an attribute name, the statement value=model.name whould assign the |
| 798 |
|
value object.name to value.). If the name of the parameters of a model |
| 799 |
|
and an object don't match the setParameter method of model can be used. |
| 800 |
|
So |
| 801 |
|
|
| 802 |
model.setParameter(name,object,name_for_object) |
model.setParameter(name,object,name_for_object) |
| 803 |
|
|
| 804 |
links the parameter name of model with the parameter name_for_object of object. |
links the parameter name of model with the parameter name_for_object of |
| 805 |
|
object. |
| 806 |
|
|
| 807 |
The run method initiates checkpointing (it is not clear how to do this yet) |
The run method initiates checkpointing (it is not clear how to do this |
| 808 |
|
yet) |
| 809 |
===== |
===== |
| 810 |
|
|
| 811 |
""" |
""" |
|
# step size used in case of an undefined value for the step size |
|
|
UNDEF_DT=1.e300 |
|
| 812 |
|
|
|
def __init__(self,submodels=[],parameters={},name="model",description="none",check_pointing=None,debug=False): |
|
|
"""initiates a model from a list of submodels. """ |
|
|
self.setDebug(debug) |
|
|
self.__check_pointing=check_pointing |
|
|
self.__parameters={} |
|
|
self.setName(name) |
|
|
self.setDescription(description) |
|
|
self.declareParameter(**parameters) |
|
|
# get the models defined in parameters: |
|
|
self.__submodels=[] |
|
|
# submodels==None means no submodels used: |
|
|
if submodels==None: |
|
|
pass |
|
|
# no submodel list given means all submodels are used as defined by the parameters dictionary: |
|
|
elif len(submodels)==0: |
|
|
for i in parameters.keys(): |
|
|
if isinstance(parameters[i],Model): self.__submodels.append(i) |
|
|
# submodel list of strings and Models is given, submodels defines the order in which the |
|
|
# submodels are processed. if new models are found in the list they are added to the parameter dictionary. |
|
|
else: |
|
|
c=0 |
|
|
for i in submodels: |
|
|
if isinstance(i,StringType): |
|
|
m=self.getParameter(i) |
|
|
if not isinstance(m,Model): |
|
|
raise ValueError,"submodel %s is not a model."%i |
|
|
else: |
|
|
if not isinstance(i,Model): |
|
|
raise ValueError,"submodel list does contain item which is not a Model class object." |
|
|
m=i |
|
|
i="__submodel%d__"%c |
|
|
self.declareParameter(**{i : m}) |
|
|
c+=1 |
|
|
self.__submodels.append(i) |
|
|
if self.debug(): print "%s: model %s is added as parameter %s."%(self,m,i) |
|
|
if len(self.__submodels)>0 and self.debug(): print "%s: model ordering is %s"%(self,self.__submodels) |
|
|
def setSubmodelOrder(submodels=[]): |
|
|
"""sets a new ordering for submodels""" |
|
|
|
|
|
|
|
|
# |
|
|
# some basic fuctions: |
|
|
# |
|
|
def debugOn(self): |
|
|
"""sets debugging to on""" |
|
|
self.__debug=True |
|
|
def debugOff(self): |
|
|
"""sets debugging to off""" |
|
|
self.__debug=False |
|
|
def debug(self): |
|
|
"""returns True if debug mode is set to on""" |
|
|
return self.__debug |
|
|
def setDebug(self,flag=False): |
|
|
"""sets debugging to flag""" |
|
|
if flag: |
|
|
self.debugOn() |
|
|
else: |
|
|
self.debugOff() |
|
|
def setDebug(self,flag=False): |
|
|
"""sets debugging to flag""" |
|
|
if flag: |
|
|
self.debugOn() |
|
|
else: |
|
|
self.debugOff() |
|
|
# name and description handling |
|
|
def __str__(self): |
|
|
"""returns the name of the model""" |
|
|
return self.getName() |
|
|
|
|
|
def getName(self): |
|
|
"""returns the name of the model""" |
|
|
return self.__name |
|
|
|
|
|
def getFullName(self): |
|
|
"""returns the full name of the model including all the names of the submodels""" |
|
|
out=str(self)+"(" |
|
|
notfirst=False |
|
|
for i in self.__submodels: |
|
|
if notfirst: out=out+"," |
|
|
out=out+i.getFullName() |
|
|
notfirst=True |
|
|
return out+")" |
|
|
|
|
|
def setName(self,name): |
|
|
"""sets the name of the model""" |
|
|
self.__name=name |
|
|
|
|
|
def setDescription(self,description="none"): |
|
|
"""sets new description""" |
|
|
self.__description=description |
|
|
if self.debug(): print "%s: description is set to %s."%(self,description) |
|
|
def getDescription(self): |
|
|
"""returns the description of the model""" |
|
|
return self.__description |
|
|
# |
|
|
# parameter/attribute handling: |
|
|
# |
|
|
def declareParameter(self,**parameters): |
|
|
"""declares a new parameter and its inital value.""" |
|
|
for prm in parameters.keys(): |
|
|
if prm in self.__dict__.keys(): |
|
|
raise ValueError,"object attribute %s of %s cannot be used as a model parameter."%(prm,self) |
|
|
self.__parameters[prm]=parameters[prm] |
|
|
if self.debug(): print "%s: parameter %s has been declared."%(self,prm) |
|
|
|
|
|
|
|
|
|
|
|
def showParameters(self): |
|
|
"""returns a descrition of the parameters""" |
|
|
out="" |
|
|
notfirst=False |
|
|
for i in self.__parameters: |
|
|
if notfirst: out=out+"," |
|
|
notfirst=True |
|
|
out="%s%s=%s"%(out,i,self.__parameters[i]) |
|
|
return out |
|
|
|
|
|
|
|
|
def deleteParameter(self,name): |
|
|
"""removes parameter name from the model""" |
|
|
raise IllegalParameterError("Cannot delete parameter %s."%name) |
|
|
|
|
|
def getParameter(self,name): |
|
|
"""returns the value of parameter name. If the parameter is not declared in self, the submodels are searched. |
|
|
if the parameter is a Link, the current value of the obejective is returned.""" |
|
|
if self.__parameters.has_key(name): |
|
|
if isinstance(self.__parameters[name],Link): |
|
|
out=self.__parameters[name].getValue(name) |
|
|
else: |
|
|
out=self.__parameters[name] |
|
|
else: |
|
|
out=None |
|
|
for i in self.__submodels: |
|
|
try: |
|
|
out=self.__parameters[i].getParameter(name) |
|
|
except IllegalParameterError: |
|
|
pass |
|
|
if out==None: raise IllegalParameterError("Cannot find parameter %s."%name) |
|
|
return out |
|
|
|
|
|
def setParameter(self,**parameters): |
|
|
"""sets parameter name to value. If the initial value for the parameter is a Model, the new value has to be a Model.""" |
|
|
for name in parameters.keys(): |
|
|
if self.__parameters.has_key(name): |
|
|
if not isinstance(parameters[name],Model) and isinstance(self.__parameters[name],Model): |
|
|
raise ValueError,"%s: parameter %s can assigned to a Model object only."%(self,name) |
|
|
if isinstance(parameters[name],Model) and not isinstance(self.__parameters[name],Model): |
|
|
raise ValueError,"%s: parameter %s is not declared as a Model."%(self,name) |
|
|
self.__parameters[name]=parameters[name] |
|
|
if isinstance(self.__parameters[name],Link): |
|
|
if not self.__parameters[name].hasAttributeName(): self.__parameters[name].setAttributeName(name) |
|
|
if self.debug(): print "%s: parameter %s has now value %s"%(self,name,self.__parameters[name]) |
|
|
else: |
|
|
set=False |
|
|
for i in self.__submodels: |
|
|
try: |
|
|
self.__parameters[i].setParameter(**{name : parameters[name]}) |
|
|
set=True |
|
|
except IllegalParameterError: |
|
|
pass |
|
|
if not set: raise IllegalParameterError("%s: Attempt to set undeclared parameter %s."%(self,name)) |
|
|
|
|
|
def hasParameter(self,name): |
|
|
"""returns True if self or one of the submodels has parameter name""" |
|
|
if self.__parameters.has_key(name): |
|
|
out=True |
|
|
else: |
|
|
out=False |
|
|
for i in self.__submodels: out= out or self.__parameters[i].hasParameter(name) |
|
|
return out |
|
|
|
|
|
def checkParameter(self,name): |
|
|
"""checks if self has the parameter name. Otherewise ParameterError is thrown.""" |
|
|
if not self.hasParameter(name): |
|
|
raise ParameterError("%s has no parameter %s."%(str(self),name)) |
|
|
|
|
|
def __getattr__(self,name): |
|
|
"""returns the value for attribute name. If name is in the Link list, the corresponding attribute is returned.""" |
|
|
if self.__dict__.has_key(name): |
|
|
return self.__dict__[name] |
|
|
elif self.__dict__.has_key("_Model__parameters") and self.__dict__.has_key("_Model__submodels"): |
|
|
return self.getParameter(name) |
|
|
else: |
|
|
raise AttributeError,"No attribute %s."%name |
|
|
|
|
|
def __setattr__(self,name,value): |
|
|
"""returns the value for attribute name.""" |
|
|
if self.__dict__.has_key("_Model__parameters") and self.__dict__.has_key("_Model__submodels"): |
|
|
if self.hasParameter(name): |
|
|
self.setParameter(**{ name : value }) |
|
|
else: |
|
|
self.__dict__[name]=value |
|
|
else: |
|
|
self.__dict__[name]=value |
|
|
|
|
|
def __delattr__(self,name): |
|
|
"""removes the attribute name.""" |
|
|
if self.__dict__.has_key(name): |
|
|
del self.__dict__[name] |
|
|
elif self.__dict__.has_key("_Model__parameters"): |
|
|
self.deleteParameter(name) |
|
|
else: |
|
|
raise AttributeError,"No attribute %s."%name |
|
|
|
|
|
# |
|
|
# submodel handeling: |
|
|
# |
|
|
def doInitializationOfSubmodels(self): |
|
|
"""initializes the time stepping for all submodels.""" |
|
|
for i in self.__submodels: self.getParameter(i).doInitialization() |
|
|
|
|
|
def getSafeTimeStepSizeFromSubmodels(self): |
|
|
"""returns a time step size which can savely be used by all submodels. To avoid a big increase in the step size, |
|
|
the new step size is restricted to the double of the precious step size.""" |
|
|
out=None |
|
|
for i in self.__submodels: |
|
|
dt=self.getParameter(i).getSafeTimeStepSize() |
|
|
if not dt==None: |
|
|
if out==None: |
|
|
out=dt |
|
|
else: |
|
|
out=min(out,dt) |
|
|
return out |
|
|
|
|
|
def doStepOfSubmodels(self,t): |
|
|
"""executes the time step for each submodel""" |
|
|
for i in self.__submodels: self.getParameter(i).doStep(t) |
|
|
|
|
|
def finalizeAllSubmodels(self): |
|
|
"""returns True if all submodels can be finalized""" |
|
|
out=True |
|
|
for i in self.__submodels: out = out and self.getParameter(i).finalize() |
|
|
return out |
|
|
|
|
|
def doFinalizationOfSubmodels(self): |
|
|
"""finalalizes the time stepping for each of the submodels.""" |
|
|
for i in self.__submodels: self.getParameter(i).doFinalization() |
|
|
|
|
|
def doIterationInitializationOfSubmodels(self,t): |
|
|
"""initializes the iteration for each of the submodels.""" |
|
|
for i in self.__submodels: self.getParameter(i).doIterationInitialization(t) |
|
|
|
|
|
def doIterationStepOfSubmodels(self): |
|
|
"""executes the iteration step at time step for each submodel""" |
|
|
for i in self.__submodels: self.getParameter(i).doIterationStep() |
|
|
|
|
|
def terminateAllSubmodels(self): |
|
|
"""returns True if all iterations for all submodels are terminated.""" |
|
|
out=True |
|
|
for i in self.__submodels: out = out and self.getParameter(i).terminate() |
|
|
return out |
|
|
|
|
|
def doIterationFinalizationOfSubmodels(self): |
|
|
"""finalalizes the iteration process for each of the submodels.""" |
|
|
for i in self.__submodels: self.getParameter(i).doIterationFinalization() |
|
|
|
|
|
def checkPointSubmodels(self): |
|
|
"""performs check pointing for each submodel""" |
|
|
for i in self.__submodels: self.getParameter(i).checkPoint() |
|
|
|
|
|
# |
|
|
# these methods control the time stepping |
|
|
# |
|
|
def doInitialization(self): |
|
|
"""initializes the time stepping""" |
|
|
self.doInitializationOfSubmodels() |
|
|
|
|
|
def getSafeTimeStepSize(self): |
|
|
"""returns a time step size which can savely be used""" |
|
|
return self.getSafeTimeStepSizeFromSubmodels() |
|
|
|
|
|
def doStep(self,t): |
|
|
"""executes the time step by first iterating over time step t and then step forward""" |
|
|
# run iteration on simulation until terminated: |
|
|
self.doIterationInitialization(t) |
|
|
while not self.terminate(): self.doIterationStep() |
|
|
self.doIterationFinalization() |
|
|
self.doStepOfSubmodels(t) |
|
|
|
|
|
def finalize(self): |
|
|
"""returns True if all submodels are to be finalized""" |
|
|
return self.finalizeAllSubmodels() |
|
|
|
|
|
def doFinalization(self): |
|
|
"""finalizes the time stepping.""" |
|
|
self.doFinalizationOfSubmodels() |
|
|
# |
|
|
# methods deal with iterations: |
|
|
# |
|
|
def doIterationInitialization(self,t): |
|
|
"""initializes the iteration on a time step""" |
|
|
self.__iter=0 |
|
|
if self.debug(): print "%s: iteration starts"%self |
|
|
self.doIterationInitializationOfSubmodels(t) |
|
|
|
|
|
def doIterationStep(self): |
|
|
"""executes the iteration step""" |
|
|
self.__iter+=1 |
|
|
if self.debug(): print "%s: iteration step %d"%(self,self.__iter) |
|
|
try: |
|
|
self.doIterationStepOfSubmodels() |
|
|
except IterationDivergenceError,e: |
|
|
raise IterationDivergenceError("divergence at time step %s in iteration step %s by reason: \n%s."%(self.__n,self.__iter,e.value)) |
|
|
|
|
|
def terminate(self): |
|
|
"""returns True if time steping is terminated""" |
|
|
return self.terminateAllSubmodels() |
|
|
|
|
|
def doIterationFinalization(self): |
|
|
"""finalalizes the iteration process.""" |
|
|
self.doIterationFinalizationOfSubmodels() |
|
|
if self.debug(): print "%s: iteration finalized after %s step"%(self,self.__iter) |
|
|
# |
|
|
# sum other method: |
|
|
# |
|
|
def checkPoint(self): |
|
|
"""performs check pointing for each submodel""" |
|
|
if not self.__check_pointing==None: |
|
|
if self.__n%self.__check_pointing==0: self.checkPointsSubmodels() |
|
|
|
|
|
def run(self): |
|
|
"""After check_pointing time steps the model will start to create checkpoint files for each of the submodels""" |
|
|
self.__tn=0. |
|
|
self.__n=0 |
|
|
self.__dt=None |
|
|
self.doInitialization() |
|
|
while not self.finalize(): |
|
|
self.__n+=1 |
|
|
self.__dt=self.getSafeTimeStepSize() |
|
|
if self.__dt==None: self.__dt=self.UNDEF_DT |
|
|
if self.debug(): print "%s: %d. time step %e (step size %e.)"%(self,self.__n,self.__tn+self.__dt,self.__dt) |
|
|
endoftimestep=False |
|
|
while not endoftimestep: |
|
|
endoftimestep=True |
|
|
try: |
|
|
self.doStep(self.__tn+self.__dt) |
|
|
except FailedTimeStepError: |
|
|
self.__dt=self.getSafeTimeStepSize() |
|
|
if self.__dt==None: self.__dt=self.UNDEF_DT |
|
|
endoftimestep=False |
|
|
if self.debug(): print "%s: time step is repeated with new step size %e."%(self,self.__dt) |
|
|
except IterationDivergenceError: |
|
|
self.__dt*=0.5 |
|
|
endoftimestep=False |
|
|
if self.debug(): print "%s: iteration failes. time step is repeated with new step size %e."%(self,self.__dt) |
|
|
self.checkPoint() |
|
|
self.__tn+=self.__dt |
|
|
self.doFinalization() |
|
| 813 |
|
|
|
class IterationDivergenceError(Exception): |
|
|
"""excpetion which should be thrown if an iteration at a time step fails""" |
|
|
pass |
|
| 814 |
|
|
| 815 |
class FailedTimeStepError(Exception): |
if __name__=="__main__": |
| 816 |
"""excpetion which should be thrown if the time step fails because of a step size that have been choosen to be to large""" |
import math |
| 817 |
pass |
# |
| 818 |
|
# test for parameter set |
| 819 |
|
# |
| 820 |
|
p11=ParameterSet() |
| 821 |
|
p11.declareParameter(gamma1=1.,gamma2=2.,gamma3=3.) |
| 822 |
|
p1=ParameterSet() |
| 823 |
|
p1.declareParameter(dim=2,tol_v=0.001,output_file="/tmp/u.%3.3d.dx",runFlag=True,parm11=p11) |
| 824 |
|
parm=ParameterSet({ "parm1" : p1 , "parm2" : ParameterSet(["alpha"])}) |
| 825 |
|
parm.parm2.alpha=Link(p11,"gamma1") |
| 826 |
|
parm.x="that should not be here!" |
| 827 |
|
print parm.showParameters() |
| 828 |
|
# should be something like: {"parm2" : {"alpha" : reference to attribute |
| 829 |
|
# gamma1 of <__main__.ParameterSet instance at 0xf6db51cc>},"parm1" : {"dim" |
| 830 |
|
# : 2,"runFlag" : True,"tol_v": 0.001,"parm11" : {"gamma3" : 3.0,"gamma2" : |
| 831 |
|
# 2.0,"gamma1" : 1.0},"output_file" : /tmp/u.%3.3d.dx}} |
| 832 |
|
assert parm.parm2.alpha==1. |
| 833 |
|
parm.writeXML() |
| 834 |
|
|
| 835 |
|
#======================= |
| 836 |
|
class Messenger(Model): |
| 837 |
|
def __init__(self): |
| 838 |
|
Model.__init__(self) |
| 839 |
|
self.declareParameter(message="none") |
| 840 |
|
|
| 841 |
|
def doInitialization(self,t): |
| 842 |
|
self.__t=t |
| 843 |
|
print "I start talking now!" |
| 844 |
|
|
| 845 |
|
def doStep(self,dt): |
| 846 |
|
self.__t+=dt |
| 847 |
|
print "Message (time %e) : %s "%(self.__t,self.message) |
| 848 |
|
|
| 849 |
class IllegalParameterError(Exception): |
def doFinalization(self): |
| 850 |
"""excpetion which is thrown if model has not the desired parameter""" |
print "I have no more to say!" |
| 851 |
pass |
|
| 852 |
|
class ODETEST(Model): |
| 853 |
|
""" implements a solver for the ODE |
| 854 |
|
|
| 855 |
|
du/dt=a*u+f(t) |
| 856 |
|
|
| 857 |
if __name__=="__main__": |
we use a implicit euler scheme : |
|
class Messenger(Model): |
|
|
def __init__(self): |
|
|
Model.__init__(self,parameters={"message" : "none" },name="messenger") |
|
| 858 |
|
|
| 859 |
def doInitialization(self): |
u_n-u_{n-1}= dt*a u_n + st*f(t_n) |
|
print "I start talking now!" |
|
| 860 |
|
|
| 861 |
def doStep(self,t): |
to get u_n we run an iterative process |
| 862 |
print "Message (time %e) : %s "%(t,self.message) |
|
| 863 |
|
u_{n.k}=u_{n-1}+dt*(a u_{n.i-1} + f(t_n)) |
| 864 |
|
|
| 865 |
def doFinalization(self): |
|
| 866 |
print "I have no more to say!" |
input for this model are step size dt, end time tend and a value for |
| 867 |
|
a, f and initial value for u. we need also a tolerance tol for a |
| 868 |
# explicit scheme |
stopping criterion. |
| 869 |
class Ode1(Model): |
|
| 870 |
def __init__(self,**args): |
""" |
| 871 |
Model.__init__(self,parameters={"tend" : 1., "dt" : 0.0001 ,"a" : 0.1 ,"u" : 1. , "message" : "none" },name="Ode1",debug=True) |
|
| 872 |
|
def __init__(self): |
| 873 |
def doInitialization(self): |
Model.__init__(self,debug=True) |
| 874 |
self._tn=0 |
self.declareParameter(tend=1.,dt=0.1,a=0.9,u=10.,f=0.,message="",tol=1.e-8) |
| 875 |
|
|
| 876 |
def doStep(self,t): |
def doInitialization(self,t): |
| 877 |
self.u=self.u+(t-self._tn)*self.a*self.u**2 |
self.__tn=t |
| 878 |
self._tn=t |
self.__iter=0 |
| 879 |
|
|
| 880 |
def doFinalization(self): |
def doIterationInitialization(self,dt): |
| 881 |
self.message="current error = %e"%abs(self.u-1./(1./3.-self.a*self._tn)) |
self.__iter=0 |
| 882 |
print self.message |
self.__u_last=self.u |
| 883 |
|
|
| 884 |
def getSafeTimeStepSize(self): |
def doIterationStep(self,dt): |
| 885 |
return self.dt |
self.__iter+=1 |
| 886 |
|
self.__u_old=self.u |
| 887 |
def finalize(self): |
self.u=self.__u_last+dt*(self.a*self.__u_old+self.f) |
| 888 |
return self._tn>=self.tend |
|
| 889 |
# explicit scheme |
def terminate(self): |
| 890 |
class Ode2(Model): |
if self.__iter<1: |
| 891 |
|
return False |
| 892 |
def __init__(self,**args): |
else: |
| 893 |
Model.__init__(self,parameters={"tend" : 1., "dt" : 0.0001 ,"a" : 0.1 ,"u" : 10000. },name="Ode2",debug=True) |
return abs(self.__u_old-self.u)<self.tol*abs(self.u) |
| 894 |
self.declareParameter(tol=1.e-8,message="none") |
|
| 895 |
|
def doIterationFinalization(self,dt): |
| 896 |
|
self.__tn+=dt |
| 897 |
def doInitialization(self): |
self.message="current error = %e"%abs(self.u-10.*math.exp((self.a-1.)*self.__tn)) |
| 898 |
self._tn=0 |
|
| 899 |
self._iter=0 |
def getSafeTimeStepSize(self,dt): |
| 900 |
|
return min(self.dt,1./(abs(self.a)+1.)) |
| 901 |
def doIterationInitialization(self,t): |
|
| 902 |
self._iter=0 |
def finalize(self): |
| 903 |
self._u_last=self.u |
return self.__tn>=self.tend |
| 904 |
self._dt=t-self._tn |
|
| 905 |
self._tn=t |
# |
| 906 |
|
# s solves the coupled ODE: |
| 907 |
def doIterationStep(self): |
# |
| 908 |
self._iter+=1 |
# du/dt=a*u+ v |
| 909 |
self._u_old=self.u |
# dv/dt= u+a*v |
| 910 |
self.u=(self._dt*self.a*self.u**2-self._u_last)/(2*self._dt*self.a*self.u-1.) |
# |
| 911 |
|
# each equation is treated through the ODETEST class. The equations are |
| 912 |
def terminate(self): |
# linked and iteration over each time step is performed. the current |
| 913 |
if self._iter<1: |
# error of v is reported by the Messenger class. |
| 914 |
return False |
# |
| 915 |
else: |
o1=ODETEST() |
| 916 |
return abs(self._u_old-self.u)<self.tol*abs(self.u) |
o1.u=10 |
| 917 |
|
o2=ODETEST() |
| 918 |
def doIterationFinalization(self): |
o2.u=-10. |
| 919 |
self.message="current error = %e"%abs(self.u-1./(1-self.a*self._tn)) |
o1.f=Link(o2,"u") |
| 920 |
print self.message |
o2.f=Link(o1,"u") |
| 921 |
|
m=Messenger() |
| 922 |
def getSafeTimeStepSize(self): |
o1.dt=0.01 |
| 923 |
return self.dt |
m.message=Link(o1) |
| 924 |
|
s=ExplicitSimulation([Simulation([o1,o2],debug=True),m],debug=True) |
| 925 |
def finalize(self): |
s.run() |
| 926 |
return self._tn>=self.tend |
s.writeXML() |
|
|
|
|
# a simple model with paramemter tend, dt, p1, p2, and p3 |
|
|
class Test1(Model): |
|
|
|
|
|
def __init__(self,**args): |
|
|
Model.__init__(self,{"tend" : 1., "dt" : 0.1 ,"p1" : 0 ,"p2" : 0 ,"p3" : 0 },"test","bla",None,True) |
|
|
self.setParameters(args) |
|
|
|
|
|
def doInitialization(self): |
|
|
self.__tn=0 |
|
|
self.__n=0 |
|
|
|
|
|
def doStep(self,t): |
|
|
self.p3=self.p1+t*self.p2 |
|
|
self.__tn=t |
|
|
print "test1 set the value out1 to ",self.p3 |
|
|
|
|
|
def doFinalization(self): |
|
|
pass |
|
|
|
|
|
def getSafeTimeStepSize(self): |
|
|
return self.dt |
|
|
|
|
|
def finalize(self): |
|
|
return self._tn>self.tend |
|
|
|
|
|
|
|
|
class Test2(Model): |
|
|
|
|
|
def __init__(self): |
|
|
Model.__init__(self,{"q1": None},"test2","",None,True) |
|
|
|
|
|
|
|
|
def doInitialization(self): |
|
|
print "the whole thing starts" |
|
|
|
|
|
def doStep(self,t): |
|
|
print "test2 things that out1 is now ",self.out1 |
|
|
|
|
|
def doFinalization(self): |
|
|
print "all done" |
|
|
|
|
|
def finalize(self): |
|
|
return True |
|
|
|
|
|
class Test12(Model): |
|
|
"""model build from two models in a transperent way""" |
|
|
def __init__(self): |
|
|
Model.__init__(self,{"sm1": None, a : 0, "sm2": None},"test2","",None,True) |
|
|
self.setExecutionOrder(["sm2","sm1"]) |
|
|
|
|
|
# test messenger |
|
|
m=Messenger() |
|
|
m.run() |
|
|
# ode1 |
|
|
o=Ode1() |
|
|
o.dt=0.001 |
|
|
o.u=3. |
|
|
o.run() |
|
|
# ode1 |
|
|
o=Ode2() |
|
|
o.dt=0.01 |
|
|
o.a=0.1 |
|
|
o.u=1. |
|
|
o.run() |
|
|
# and they are linked together: |
|
|
o=Ode2() |
|
|
m=Messenger() |
|
|
om=Model(submodels=[o,m],debug=True) |
|
|
om.dt=0.01 |
|
|
om.u=1. |
|
|
m.message=Link(o) |
|
|
om.run() |
|
|
print om.showParameters() |
|
|
1/0 |
|
|
|
|
|
t=Test1() |
|
|
t.tend=1. |
|
|
t.dt=0.25 |
|
|
t.in1=1. |
|
|
t.in2=3. |
|
|
t.run() |
|
|
# and a coupled problem: |
|
|
t2=Test2() |
|
|
t2.out1=Link(t) |
|
|
Model([t,t2],debug=True).run() |
|
Parent Directory
| 
Revision Log
| 
Patch