def set(self, **kw):
if 'abseps' in kw:
# pass up to generic treatment for this
ctsGen.set(self, abseps=kw['abseps'])
for x in self._xdatadict:
self.variables[x] = Variable(interp(copy(self.tdata),
self.funcspec[x].toarray()), 't',
Interval(x, self.xtype[x], self.xdomain[x],
self._abseps), x)
if 'checklevel' in kw:
# pass up to generic treatment for this
ctsGen.set(self, checklevel=kw['checklevel'])
if 'globalt0' in kw:
# pass up to generic treatment for this
ctsGen.set(self, globalt0=kw['globalt0'])
def set(self, **kw):
"""Set ODE system parameters"""
if remain(kw.keys(), self._validKeys) != []:
raise KeyError("Invalid keys in argument")
if 'globalt0' in kw:
# pass up to generic treatment for this
ctsGen.set(self, globalt0=kw['globalt0'])
# set this True so that can adjust the input time arrays
# to new globalt0
self._extInputsChanged = True
if 'checklevel' in kw:
# pass up to generic treatment for this
ctsGen.set(self, checklevel=kw['checklevel'])
if 'abseps' in kw:
# pass up to generic treatment for this
ctsGen.set(self, abseps=kw['abseps'])
# optional keys for this call are ['pars', 'tdomain', 'ics',
# 'algparams', 'tdata', 'xdomain', 'pdomain', 'inputs']
if 'ics' in kw:
for k_temp, v in kw['ics'].iteritems():
k = self._FScompatibleNames(k_temp)
if k in self.funcspec.vars+self.funcspec.auxvars:
self._xdatadict[k] = ensurefloat(v)
else:
raise ValueError('Illegal variable name %s'%k)
self.initialconditions.update(self._xdatadict)
tchange = False
if 'tdata' in kw:
self.tdata = kw['tdata']
tchange = True
if 'tdomain' in kw:
self.tdomain = kw['tdomain']
self.indepvariable.indepdomain.set(self.tdomain)
tchange = True
if tchange:
if self.tdomain[0] > self.tdata[0]:
if self.indepvariable.indepdomain.contains(self.tdata[0]) == uncertain:
self.diagnostics.warnings.append((W_UNCERTVAL,
(self.tdata[0],self.tdomain)))
else:
print 'tdata cannot be specified below smallest '\
'value in tdomain\n (possibly due to uncertain bounding).'\
' It has been automatically adjusted from\n ', \
self.tdata[0], 'to', self.tdomain[0], '(difference of', \
self.tdomain[0]-self.tdata[0], ')'
if self._modeltag:
print 'Try reducing step size in model.'
self.tdata[0] = self.tdomain[0]
if self.tdomain[1] < self.tdata[1]:
if self.indepvariable.indepdomain.contains(self.tdata[1]) == uncertain:
self.diagnostics.warnings.append((W_UNCERTVAL,
(self.tdata[1],self.tdomain)))
else:
print 'tdata cannot be specified above largest '\
'value in tdomain\n (possibly due to uncertain bounding).'\
' It has been automatically adjusted from\n ', \
self.tdomain[1], 'to', \
self.tdomain[1], '(difference of', \
self.tdata[1]-self.tdomain[1], ')'
if self._modeltag:
print 'Try reducing step size in model.'
self.tdata[1] = self.tdomain[1]
self.indepvariable.depdomain.set(self.tdata)
if 'xdomain' in kw:
for k_temp, v in kw['xdomain'].iteritems():
k = self._FScompatibleNames(k_temp)
if k in self.funcspec.vars+self.funcspec.auxvars:
if isinstance(v, _seq_types):
assert len(v) == 2, \
"Invalid size of domain specification for "+k
if v[0] >= v[1]:
raise PyDSTool_ValueError('xdomain values must be'
'in order of increasing '
'size')
else:
self.xdomain[k] = copy(v)
elif isinstance(v, _num_types):
self.xdomain[k] = [v, v]
else:
raise PyDSTool_TypeError('Invalid type for xdomain spec'
' '+k)
else:
raise ValueError('Illegal variable name')
try:
self.variables[k].depdomain.set(v)
except TypeError:
raise TypeError('xdomain must be a dictionary of variable'
' names -> valid interval 2-tuples or '
'singletons')
try:
evs = self.eventstruct.events.values()
except AttributeError:
evs = []
for ev in evs:
ev.xdomain[k] = self.xdomain[k]
if 'pdomain' in kw:
for k_temp, v in kw['pdomain'].iteritems():
k = self._FScompatibleNames(k_temp)
if k in self.funcspec.pars:
if isinstance(v, _seq_types):
assert len(v) == 2, \
"Invalid size of domain specification for "+k
if v[0] >= v[1]:
raise PyDSTool_ValueError('pdomain values must be'
'in order of increasing '
'size')
else:
self.pdomain[k] = copy(v)
elif isinstance(v, _num_types):
self.pdomain[k] = [v, v]
else:
raise PyDSTool_TypeError('Invalid type for pdomain spec'
' '+k)
else:
raise ValueError('Illegal parameter name')
try:
self.parameterDomains[k].depdomain.set(v)
except TypeError:
raise TypeError('xdomain must be a dictionary of parameter'
' names -> valid interval 2-tuples or '
'singletons')
try:
evs = self.eventstruct.events.values()
except AttributeError:
evs = []
for ev in evs:
ev.pdomain[k] = self.pdomain[k]
if 'pars' in kw:
for k_temp, v in kw['pars'].iteritems():
k = self._FScompatibleNames(k_temp)
if k in self.pars:
cval = self.parameterDomains[k].contains(v)
if self.checklevel < 3:
if cval is not notcontained:
self.pars[k] = ensurefloat(v)
if cval is uncertain and self.checklevel == 2:
print 'Warning: Parameter %s: value at bound'%str(k)
else:
raise PyDSTool_ValueError('Parameter %s: value out of bounds'%str(k))
else:
if cval is contained:
self.pars[k] = ensurefloat(v)
elif cval is uncertain:
raise PyDSTool_UncertainValueError('Parameter %s: value at bound'%str(k))
else:
raise PyDSTool_ValueError('Parameter %s: value out of bounds'%str(k))
else:
raise PyDSTool_ValueError('Illegal parameter name '+str(k))
if 'algparams' in kw:
for k, v in kw['algparams'].iteritems():
self.algparams[k] = v
if k in ('eventActive', 'eventTol', 'eventDelay', 'eventDir', 'eventInt', 'eventTerm',
'maxbisect'):
raise ValueError("Use appropriate setX method in Generator.eventstruct")
if 'inputs' in kw:
assert self.inputs, ('Cannot provide inputs after '
'initialization without them')
inputs = copy(kw['inputs'])
_inputs = {}
if isinstance(inputs, Trajectory):
# extract the variables
_inputs = self._FScompatibleNames(inputs.variables)
elif isinstance(inputs, Variable):
_inputs = {self._FScompatibleNames(inputs.name): inputs}
elif isinstance(inputs, Pointset):
# turn into Variables
for n in inputs.coordnames:
x_array = inputs[n]
nFS = self._FScompatibleNames(n)
_input[nFS] = Variable(interp1d(inputs.indepvararray,
x_array), 't',
Interval(nFS, float, extent(x_array),
abseps=self._abseps),
name=n)
elif isinstance(inputs, dict):
_inputs = self._FScompatibleNames(inputs)
# ensure values are Variables
for v in _inputs.values():
if not isinstance(v, Variable):
raise TypeError("Invalid specification of inputs")
else:
raise TypeError("Invalid specification of inputs")
for v in _inputs.values():
if not iscontinuous(v):
raise ValueError("External inputs for ODE system must be "
"continously defined")
if _inputs:
for i in _inputs:
assert i in self.inputs, 'Incorrect input name provided'
self.inputs[i] = _inputs[i]
# re-calc inputs ixmaps
self._generate_ixmaps('inputs')
self._extInputsChanged = True
if 'inputs_t0' in kw:
assert self.inputs, ('Cannot provide inputs after '
'initialization without them')
inputs_t0 = self._FScompatibleNames(kw['inputs_t0'])
for iname, t0 in inputs_t0.items():
self.inputs[iname]._internal_t_offset = t0
self._extInputsChanged = True
def set(self, **kw):
"""Set ImplicitFnGen parameters"""
if remain(kw.keys(), self._validKeys) != []:
raise KeyError("Invalid keys in argument")
if 'globalt0' in kw:
# pass up to generic treatment for this
ctsGen.set(self, globalt0=kw['globalt0'])
if 'checklevel' in kw:
# pass up to generic treatment for this
ctsGen.set(self, checklevel=kw['checklevel'])
if 'abseps' in kw:
# pass up to generic treatment for this
ctsGen.set(self, abseps=kw['abseps'])
# optional keys for this call are ['pars', 'tdomain', 'xdomain', 'pdomain']
if 'xdomain' in kw:
for k_temp, v in kw['xdomain'].iteritems():
k = self._FScompatibleNames(k_temp)
if k in self.funcspec.vars+self.funcspec.auxvars:
if isinstance(v, _seq_types):
assert len(v) == 2, \
"Invalid size of domain specification for "+k
if v[0] >= v[1]:
raise PyDSTool_ValueError('xdomain values must be'
'in order of increasing '
'size')
elif isinstance(v, _num_types):
pass
else:
raise PyDSTool_TypeError('Invalid type for xdomain spec'
' '+k)
self.xdomain[k] = v
else:
raise ValueError('Illegal variable name')
try:
self.variables[k].depdomain.set(v)
except TypeError:
raise TypeError('xdomain must be a dictionary of variable'
' names -> valid interval 2-tuples or '
'singletons')
if 'tdata' in kw:
self.tdata = kw['tdata']
if 'tdomain' in kw:
self.tdomain = kw['tdomain']
self.indepvariable.indepdomain.set(self.tdomain)
if self.tdomain[0] > self.tdata[0]:
if self.indepvariable.indepdomain.contains(self.tdata[0]) == uncertain:
self.diagnostics.warnings.append((W_UNCERTVAL,
(self.tdata[0],self.tdomain)))
else:
print 'tdata cannot be specified below smallest '\
'value in tdomain\n (possibly due to uncertain bounding).'\
' It has been automatically adjusted from\n ', self.tdata[0], \
'to', self.tdomain[0], '(difference of', \
self.tdomain[0]-self.tdata[0], ')'
self.tdata[0] = self.tdomain[0]
if self.tdomain[1] < self.tdata[1]:
if self.indepvariable.indepdomain.contains(self.tdata[1]) == uncertain:
self.diagnostics.warnings.append((W_UNCERTVAL,
(self.tdata[1],self.tdomain)))
else:
print 'tdata cannot be specified above largest '\
'value in tdomain\n (possibly due to uncertain bounding).'\
' It has been automatically adjusted from\n ', \
self.tdomain[1], 'to', \
self.tdomain[1], '(difference of', \
self.tdata[1]-self.tdomain[1], ')'
self.tdata[1] = self.tdomain[1]
self.indepvariable.depdomain.set(self.tdata)
if 'pdomain' in kw:
for k_temp, v in kw['pdomain'].iteritems():
k = self._FScompatibleNames(k_temp)
if k in self.funcspec.pars:
if isinstance(v, _seq_types):
assert len(v) == 2, \
"Invalid size of domain specification for "+k
if v[0] >= v[1]:
raise PyDSTool_ValueError('pdomain values must be'
'in order of increasing '
'size')
else:
self.pdomain[k] = copy(v)
elif isinstance(v, _num_types):
self.pdomain[k] = [v, v]
else:
raise PyDSTool_TypeError('Invalid type for pdomain spec'
' '+k)
else:
raise ValueError('Illegal parameter name')
try:
self.parameterDomains[k].depdomain.set(v)
except TypeError:
raise TypeError('pdomain must be a dictionary of parameter'
' names -> valid interval 2-tuples or '
'singletons')
if 'ics' in kw:
for k_temp, v in kw['ics'].iteritems():
k = self._FScompatibleNames(k_temp)
if k in self.funcspec.vars+self.funcspec.auxvars:
self._xdatadict[k] = ensurefloat(v)
else:
raise ValueError('Illegal variable name')
self.initialconditions.update(self._xdatadict)
if 'pars' in kw:
if not self.pars:
raise ValueError('No pars were declared for this object'
' at initialization.')
for k_temp, v in kw['pars'].iteritems():
k = self._FScompatibleNames(k_temp)
if k in self.pars:
cval = self.parameterDomains[k].contains(v)
if self.checklevel < 3:
if cval is not notcontained:
self.pars[k] = ensurefloat(v)
if cval is uncertain and self.checklevel == 2:
print 'Warning: Parameter value at bound'
else:
raise PyDSTool_ValueError('Parameter value out of bounds')
else:
if cval is contained:
self.pars[k] = ensurefloat(v)
elif cval is uncertain:
raise PyDSTool_UncertainValueError('Parameter value at bound')
else:
raise PyDSTool_ValueError('Parameter value out of bounds')
else:
raise PyDSTool_AttributeError('Illegal parameter name')
if 'algparams' in kw:
for k, v in kw['algparams'].iteritems():
self.algparams[k] = v
if 'solvemethod' in self.algparams:
if self.algparams['solvemethod'] not in _implicitSolveMethods:
raise PyDSTool_ValueError('Invalid implicit solver type')
def set(self, **kw):
"""Set ODE system parameters"""
validKeys = ['globalt0', 'xdomain', 'tdata', 'tdomain', 'checklevel',
'ics', 'pars', 'algparams', 'inputs', 'pdomain']
assert remain(kw.keys(), validKeys) == [], "Invalid keys in argument"
if 'globalt0' in kw:
# pass up to generic treatment for this
ctsGen.set(self, globalt0=kw['globalt0'])
# set this True so that can adjust the input time arrays
# to new globalt0
self._extInputsChanged = True
if 'checklevel' in kw:
# pass up to generic treatment for this
ctsGen.set(self, checklevel=kw['checklevel'])
# optional keys for this call are ['pars', 'tdomain', 'ics',
# 'algparams', 'tdata', 'xdomain', 'pdomain', 'inputs']
if 'ics' in kw:
for k_temp, v in kw['ics'].iteritems():
k = k_temp.replace(NAMESEP, "_")
if k in self.funcspec.vars+self.funcspec.auxvars:
self._xdatadict[k] = v
else:
raise ValueError, 'Illegal variable name %s'%k
self.initialconditions.update(self._xdatadict)
if 'tdata' in kw:
self._tdata = kw['tdata']
if 'tdomain' in kw:
self._tdomain = kw['tdomain']
self.indepvariable.indepdomain.set(self._tdomain)
if self._tdomain[0] > self._tdata[0]:
print 'tdata cannot be specified below smallest '\
'value in tdomain\n (possibly due to uncertain bounding).'\
' It has been automatically adjusted from\n ', \
self._tdata[0], 'to', self._tdomain[0], '(difference of', \
self._tdomain[0]-self._tdata[0], ')'
if self._modeltag:
print 'Try reducing step size in model.'
self._tdata[0] = self._tdomain[0]
if self._tdomain[1] < self._tdata[1]:
print 'tdata cannot be specified above largest '\
'value in tdomain\n (possibly due to uncertain bounding).'\
' It has been automatically adjusted from\n ', \
self._tdomain[1], 'to', \
self._tdomain[1], '(difference of', \
self._tdata[1]-self._tdomain[1], ')'
if self._modeltag:
print 'Try reducing step size in model.'
self._tdata[1] = self._tdomain[1]
self.indepvariable.depdomain.set(self._tdata)
if 'xdomain' in kw:
for k_temp, v in kw['xdomain'].iteritems():
k = k_temp.replace(NAMESEP, "_") # use internal names
if k in self.funcspec.vars+self.funcspec.auxvars:
if type(v) in [list, Array, NArray]:
assert len(v) == 2, \
"Invalid size of domain specification for "+k
if v[0] >= v[1]:
raise PyDSTool_ValueError('xdomain values must be'
'in order of increasing '
'size')
else:
self._xdomain[k] = copy(v)
elif type(v) in [float, int]:
self._xdomain[k] = [v, v]
else:
raise PyDSTool_TypeError('Invalid type for xdomain spec'
' '+k)
else:
raise ValueError, 'Illegal variable name'
try:
self.variables[k].depdomain.set(v)
except TypeError:
raise TypeError, ('xdomain must be a dictionary of variable'
' names -> valid interval 2-tuples or '
'singletons')
for ev in self.eventstruct.events.values():
ev._xdomain[k] = self._xdomain[k]
if 'pdomain' in kw:
for k_temp, v in kw['pdomain'].iteritems():
k = k_temp.replace(NAMESEP, "_") # use internal names
if k in self.funcspec.pars:
if type(v) in [list, Array, NArray]:
assert len(v) == 2, \
"Invalid size of domain specification for "+k
if v[0] >= v[1]:
raise PyDSTool_ValueError('pdomain values must be'
'in order of increasing '
'size')
else:
self._pdomain[k] = copy(v)
elif type(v) in [float, int]:
self._pdomain[k] = [v, v]
else:
raise PyDSTool_TypeError('Invalid type for pdomain spec'
' '+k)
else:
raise ValueError, 'Illegal parameter name'
try:
self.parameterDomains[k].depdomain.set(v)
except TypeError:
raise TypeError, ('xdomain must be a dictionary of parameter'
' names -> valid interval 2-tuples or '
'singletons')
for ev in self.eventstruct.events.values():
ev._pdomain[k] = self._pdomain[k]
if 'pars' in kw:
assert self.numpars > 0, ('No pars were declared for this '
'model')
for k_temp, v in kw['pars'].iteritems():
k = k_temp.replace(NAMESEP, "_")
if k in self.pars:
cval = self.parameterDomains[k].contains(v)
if self.checklevel < 3:
if cval is not notcontained:
self.pars[k] = v
if cval is uncertain and self.checklevel == 2:
print 'Warning: Parameter value at bound'
else:
raise PyDSTool_ValueError, 'Parameter value out of bounds'
else:
if cval is contained:
self.pars[k] = v
elif cval is uncertain:
raise PyDSTool_UncertainValueError, 'Parameter value at bound'
else:
raise PyDSTool_ValueError, 'Parameter value out of bounds'
else:
raise PyDSTool_ValueError, 'Illegal parameter name'
if 'algparams' in kw:
for k, v in kw['algparams'].iteritems():
self._algparams[k] = v
if 'inputs' in kw:
assert self.inputs, ('Cannot provide inputs after '
'initialization without them')
inputs = copy(kw['inputs'])
_inputs = {}
if isinstance(inputs, Trajectory):
# extract the variables
_inputs = inputs.variables
elif isinstance(inputs, Variable):
_inputs = {inputs.name: inputs}
elif isinstance(inputs, Pointset):
# turn into Variables
_inputs = dict(zip(inputs.coordnames,
[Variable(inputs[n],name=n) for n in inputs.coordnames]))
elif isinstance(inputs, dict):
_inputs = inputs
# ensure values are Variables or Pointsets
for k, v in _inputs.iteritems():
if not isinstance(v, Variable):
try:
_inputs[k]=Variable(v)
except:
raise TypeError, "Invalid specification of inputs"
else:
raise TypeError, "Invalid specification of inputs"
for v in _inputs.values():
if not iscontinuous(v):
raise ValueError, "External inputs for ODE system must be continously defined"
if _inputs:
for i in _inputs:
assert i in self.inputs, 'Incorrect input name provided'
self.inputs[i] = _inputs[i]
# re-calc inputs ixmaps
self._generate_ixmaps('inputs')
self._extInputsChanged = True
def set(self, **kw):
"""Set ImplicitFnGen parameters"""
validKeys = [
'globalt0', 'xdomain', 'tdata', 'tdomain', 'checklevel', 'ics',
'pars', 'algparams', 'pdomain'
]
assert remain(kw.keys(), validKeys) == [], "Invalid keys in argument"
if 'globalt0' in kw:
# pass up to generic treatment for this
ctsGen.set(self, globalt0=kw['globalt0'])
if 'checklevel' in kw:
# pass up to generic treatment for this
ctsGen.set(self, checklevel=kw['checklevel'])
# optional keys for this call are ['pars', 'tdomain', 'xdomain', 'pdomain']
if 'xdomain' in kw:
for k_temp, v in kw['xdomain'].iteritems():
k = k_temp.replace(NAMESEP, "_")
if k in self.funcspec.vars + self.funcspec.auxvars:
if type(v) in [list, Array, NArray]:
assert len(v) == 2, \
"Invalid size of domain specification for "+k
if v[0] >= v[1]:
raise PyDSTool_ValueError('xdomain values must be'
'in order of increasing '
'size')
elif type(v) in [float, int]:
pass
else:
raise PyDSTool_TypeError(
'Invalid type for xdomain spec'
' ' + k)
self._xdomain[k] = v
else:
raise ValueError, 'Illegal variable name'
try:
self.variables[k].depdomain.set(v)
except TypeError:
raise TypeError, (
'xdomain must be a dictionary of variable'
' names -> valid interval 2-tuples or '
'singletons')
if 'tdata' in kw:
self._tdata = kw['tdata']
if 'tdomain' in kw:
self._tdomain = kw['tdomain']
self.indepvariable.indepdomain.set(self._tdomain)
if self._tdomain[0] > self._tdata[0]:
print 'tdata cannot be specified below smallest '\
'value in tdomain\n (possibly due to uncertain bounding).'\
' It has been automatically adjusted from\n ', self._tdata[0], \
'to', self._tdomain[0], '(difference of', \
self._tdomain[0]-self._tdata[0], ')'
self._tdata[0] = self._tdomain[0]
if self._tdomain[1] < self._tdata[1]:
print 'tdata cannot be specified above largest '\
'value in tdomain\n (possibly due to uncertain bounding).'\
' It has been automatically adjusted from\n ', \
self._tdomain[1], 'to', \
self._tdomain[1], '(difference of', \
self._tdata[1]-self._tdomain[1], ')'
self._tdata[1] = self._tdomain[1]
self.indepvariable.depdomain.set(self._tdata)
if 'pdomain' in kw:
for k_temp, v in kw['pdomain'].iteritems():
k = k_temp.replace(NAMESEP, "_")
if k in self.funcspec.pars:
if type(v) in [list, Array, NArray]:
assert len(v) == 2, \
"Invalid size of domain specification for "+k
if v[0] >= v[1]:
raise PyDSTool_ValueError('pdomain values must be'
'in order of increasing '
'size')
else:
self._pdomain[k] = copy(v)
elif type(v) in [float, int]:
self._pdomain[k] = [v, v]
else:
raise PyDSTool_TypeError(
'Invalid type for pdomain spec'
' ' + k)
else:
raise ValueError, 'Illegal parameter name'
try:
self.parameterDomains[k].depdomain.set(v)
except TypeError:
raise TypeError, (
'pdomain must be a dictionary of parameter'
' names -> valid interval 2-tuples or '
'singletons')
if 'ics' in kw:
for k_temp, v in kw['ics'].iteritems():
k = k_temp.replace(NAMESEP, "_")
if k in self.funcspec.vars + self.funcspec.auxvars:
self._xdatadict[k] = v
else:
raise ValueError, 'Illegal variable name'
self.initialconditions.update(self._xdatadict)
if 'pars' in kw:
if not self.pars:
raise ValueError, ('No pars were declared for this object'
' at initialization.')
for k_temp, v in kw['pars'].iteritems():
k = k_temp.replace(NAMESEP, "_")
if k in self.pars:
cval = self.parameterDomains[k].contains(v)
if self.checklevel < 3:
if cval is not notcontained:
self.pars[k] = v
if cval is uncertain and self.checklevel == 2:
print 'Warning: Parameter value at bound'
else:
raise PyDSTool_ValueError, 'Parameter value out of bounds'
else:
if cval is contained:
self.pars[k] = v
elif cval is uncertain:
raise PyDSTool_UncertainValueError, 'Parameter value at bound'
else:
raise PyDSTool_ValueError, 'Parameter value out of bounds'
else:
raise PyDSTool_AttributeError, 'Illegal parameter name'
if 'algparams' in kw:
for k, v in kw['algparams'].iteritems():
self._algparams[k] = v
if 'solvemethod' in self._algparams:
if self._algparams['solvemethod'] not in _implicitSolveMethods:
raise PyDSTool_ValueError, 'Invalid implicit solver type'
