def __init__(self, kw):
ctsGen.__init__(self, kw)
dispatch_list = ['varspecs', 'tdomain', 'tdata', 'xtype', 'xdomain',
'ics', 'allvars', 'pars', 'pdomain', 'fnspecs',
'algparams', 'target']
if 'inputs' in kw:
raise PyDSTool_KeyError("inputs option invalid for ImplicitFnGen "
"class")
self.funcspec = ImpFuncSpec(self._kw_process_dispatch(dispatch_list, kw))
self.indepvartype = float
for s in self.funcspec.spec[0]:
if s.find('x[') > -1:
raise ValueError('Variable values cannot depend on '
'other variables in implicit function specs -- '
'in function:\n'+s)
if 'solvemethod' in self.algparams:
if self.algparams['solvemethod'] not in _implicitSolveMethods:
raise PyDSTool_ValueError('Invalid implicit solver type')
# Holder and interface for events
self.eventstruct = EventStruct()
if 'events' in kw:
raise PyDSTool_ValueError('ImplicitFnGen does not presently' \
' support events')
## self._addEvents(kw['events'])
## assert self.eventstruct.getLowLevelEvents() == [], \
## "Can only pass high level events to ImplicitFnGen objects"
## assert self.eventstruct.query(['highlevel', 'varlinked']) == [], \
## "Only non-variable linked events are valid for this class"
## self.foundKeys += 1
self.checkArgs(kw)
self.newTempVars()
self._generate_ixmaps()
def __init__(self, kw):
ctsGen.__init__(self, kw)
dispatch_list = ['tdomain', 'tdata', 'xtype', 'xdomain',
'ics', 'pars', 'pdomain', 'system']
if 'varspecs' in kw:
raise PyDSTool_KeyError('varspecs option invalid for EmbeddedSysGen '
'class')
if 'inputs' in kw:
raise PyDSTool_KeyError('inputs option invalid for EmbeddedSysGen '
'class')
try:
kw['varspecs'] = kw['system'].query('vardomains')
except (KeyError, AttributeError):
raise PyDSTool_KeyError("Model-type system must be provided")
self.funcspec = args(**self._kw_process_dispatch(dispatch_list, kw))
self.funcspec.vars = kw['varspecs'].keys()
self.funcspec.auxvars = []
# varspecs not specified by user and must be removed for checkArgs()
del kw['varspecs']
self.indepvartype = float
try:
self._embed_spec = kw['specfn']
except:
raise "Must provide a function for the specification of this system"
else:
self.foundKeys += 1
self.eventstruct = EventStruct()
self.checkArgs(kw)
assert self.eventstruct.getLowLevelEvents() == [], \
"Events are not supported for EmbeddedSysGen class"
assert self.eventstruct.getHighLevelEvents() == [], \
"Events are not supported for EmbeddedSysGen class"
self.indepvariable = Variable(listid, Interval('t_domain',
self.indepvartype,
self.tdomain, self._abseps),
Interval('t', self.indepvartype, self.tdata,
self._abseps), 't')
self._register(self.indepvariable)
for x in self.xdomain.keys():
# aux vars?
try:
xinterval=Interval(x, self.xtype[x], self.xdomain[x], self._abseps)
except KeyError, e:
raise PyDSTool_KeyError('Mismatch between declared variables '
'and xspecs: ' + str(e))
# placeholder variable so that this class can be
# copied before it is defined (listid function is a dummy)
self.variables[x] = Variable(None, self.indepvariable.depdomain,
xinterval, x)
def __init__(self, kw):
ctsGen.__init__(self, kw)
self.diagnostics._errmessages[E_COMPUTFAIL] = 'Integration failed'
# user auxiliary function interface
self.auxfns = auxfn_container(self)
dispatch_list = ['varspecs', 'tdomain', 'tdata', 'inputs',
'ics', 'allvars', 'xtype', 'xdomain',
'reuseterms', 'algparams', 'pars', 'pdomain',
'fnspecs', 'target', 'vfcodeinserts', 'ignorespecial']
# process keys and build func spec
self.funcspec = RHSfuncSpec(self._kw_process_dispatch(dispatch_list,
kw))
self.indepvartype = float
for v in self.inputs.values():
if not iscontinuous(v):
raise ValueError("External inputs for ODE system must be "
"continuously defined")
self._kw_process_events(kw)
self.checkArgs(kw)
tindepdomain = Interval('t_domain', self.indepvartype, self.tdomain,
self._abseps)
tdepdomain = Interval('t', self.indepvartype, self.tdata, self._abseps)
self.indepvariable = Variable(listid, tindepdomain, tdepdomain, 't')
self._register(self.indepvariable)
for xname in self.funcspec.vars + self.funcspec.auxvars:
# Add a temporary dependent variable domain, for validation testing
# during integration
self.variables[xname] = Variable(indepdomain=tdepdomain,
depdomain=Interval(xname,
self.xtype[xname],
self.xdomain[xname],
self._abseps))
self._register(self.variables)
self._generate_ixmaps()
# Introduce any python-specified code to the local namespace
self.addMethods()
# all registration completed
self.validateSpec()
def __init__(self, kw):
try:
self._tdata = kw['tdata']
self._xdatadict = {}
for k, v in dict(kw['ics']).iteritems():
self._xdatadict[str(k)] = v
self.foundKeys = 2
# check for other, invalid keys (but currently just ignored)
except KeyError:
raise PyDSTool_KeyError, 'Keywords missing in argument'
self._tdomain = extent(self._tdata)
self._xdomain = {}
for x in self._xdatadict:
self._xdomain[x] = extent(self._xdatadict[x])
ctsGen.__init__(self, kw)
self.funcspec = {}
if 'vars' in kw:
raise PyDSTool_KeyError, 'vars option invalid for interpolated table class'
if 'auxvars' in kw:
raise PyDSTool_KeyError, 'auxvars option invalid for interpolated table class'
if 'tdomain' in kw:
raise PyDSTool_KeyError, 'tdomain option invalid for interpolated table class'
if 'xdomain' in kw:
raise PyDSTool_KeyError, 'xdomain option invalid for interpolated table class'
if 'pdomain' in kw:
raise PyDSTool_KeyError, 'pdomain option invalid for interpolated table class'
if 'ttype' in kw:
raise PyDSTool_KeyError, 'ttype option invalid for interpolated table class'
if 'xtype' in kw:
raise PyDSTool_KeyError, 'xtype option invalid for interpolated table class'
if 'method' in kw:
if kw['method'] == 'linear':
interp = interp1d
elif kw['method'] == 'constant':
interp = interp0d
else:
raise ValueError, "Invalid interpolation method"
self.foundKeys += 1
else:
# default to piecewise linear interpolation
interp = interp1d
for x in self._xdatadict:
self.funcspec[x] = Pointset({
'coordarray': self._xdatadict[x],
'coordtype': Float,
'indepvararray': self._tdata,
'indepvartype': Float,
'indepvarname': 't',
'coordnames': x
})
self.needKeys.extend(['tdata', 'ics'])
self.optionalKeys.append('method')
self.checkArgs(kw)
self.indepvariable = Variable(
listid, Interval('t_domain', 'float', self._tdomain, self._abseps),
Interval('t', 'float', extent(self._tdata), self._abseps), 't')
self._register(self.indepvariable)
for x in self._xdatadict:
self.variables[x] = Variable(
interp(copy(self._tdata), self.funcspec[x].toarray()), 't',
Interval(x, 'float', self._xdomain[x]), x)
self._register(self.variables)
self.dimension = len(self._xdatadict)
self.validateSpec()
self.defined = True
def __init__(self, kw):
try:
self.tdata = kw['tdata']
self._xdatadict = {}
for k, v in dict(kw['ics']).iteritems():
self._xdatadict[str(k)] = v
self.foundKeys = 2
# check for other, invalid keys (but currently just ignored)
except KeyError:
raise PyDSTool_KeyError('Keywords missing in argument')
self.tdomain = extent(self.tdata)
self.xdomain = {}
for x in self._xdatadict:
self.xdomain[x] = extent(self._xdatadict[x])
ctsGen.__init__(self, kw)
self._needKeys.extend(['tdata', 'ics'])
self._optionalKeys.append('method')
self.funcspec = {} # dict, not a FuncSpec instance
if 'vars' in kw:
raise PyDSTool_KeyError('vars option invalid for interpolated table class')
if 'auxvars' in kw:
raise PyDSTool_KeyError('auxvars option invalid for interpolated table class')
if 'tdomain' in kw:
raise PyDSTool_KeyError('tdomain option invalid for interpolated table class')
if 'xdomain' in kw:
raise PyDSTool_KeyError('xdomain option invalid for interpolated table class')
if 'pdomain' in kw:
raise PyDSTool_KeyError('pdomain option invalid for interpolated table class')
if 'ttype' in kw:
raise PyDSTool_KeyError('ttype option invalid for interpolated table class')
# hack to allow xtype to run
kw['varspecs'] = {}.fromkeys(self._xdatadict, '')
self._kw_process_dispatch(['varspecs', 'xtype'], kw)
del kw['varspecs']
self.foundKeys -= 1
if 'method' in kw:
if kw['method']=='linear':
interp=interp1d
elif kw['method']=='constant':
interp=interp0d
else:
raise ValueError("Invalid interpolation method")
self.foundKeys += 1
else:
# default to piecewise linear interpolation
interp=interp1d
self.indepvartype = float
for x in self._xdatadict:
self.funcspec[x] = Pointset({'coordarray': self._xdatadict[x],
'coordtype': self.xtype[x],
'indepvararray': self.tdata,
'indepvartype': self.indepvartype,
'indepvarname': 't',
'coordnames': x})
self.checkArgs(kw)
self.indepvariable = Variable(listid, Interval('t_domain',
self.indepvartype,
self.tdomain, self._abseps),
Interval('t', self.indepvartype,
extent(self.tdata),
self._abseps), 't')
self._register(self.indepvariable)
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)
self._register(self.variables)
self.dimension = len(self._xdatadict)
self.validateSpec()
self.defined = True
def __init__(self, kw):
ctsGen.__init__(self, kw)
self._errmessages[E_COMPUTFAIL] = 'Integration failed'
self.needKeys.extend(['varspecs'])
self.optionalKeys.extend(['tdomain', 'xdomain', 'inputs', 'tdata',
'ics', 'events', 'compiler', 'enforcebounds',
'activatedbounds', 'checklevel', 'algparams',
'auxvars', 'vars', 'pars', 'fnspecs', 'pdomain',
'reuseterms', 'vfcodeinsert_start', 'vfcodeinsert_end'])
fs_args = {}
if 'varspecs' in kw:
self.foundKeys += 1
varspecs = ensureStrArgDict(kw['varspecs'])
else:
raise PyDSTool_KeyError("Keyword 'varspecs' missing from "
"argument")
if 'tdomain' in kw:
self._tdomain = kw['tdomain']
if self._tdomain[0] >= self._tdomain[1]:
print "Time domain specified: [%s, %s]"%(self._tdomain[0], self._tdomain[1])
raise PyDSTool_ValueError('tdomain values must be in order of increasing size')
self.foundKeys += 1
else:
self._tdomain = [-Inf, Inf]
if 'tdata' in kw:
self._tdata = kw['tdata']
if self._tdata[0] >= self._tdata[1]:
raise PyDSTool_ValueError('tdata values must be in order of increasing size')
# _tdata is made into list to be consistent with
# other uses of it in other Generators...
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\n'\
' 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\n'\
' from\n ', self._tdata[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.foundKeys += 1
else:
self._tdata = self._tdomain # default needed
if 'inputs' in kw:
inputs = copy(kw['inputs'])
self.inputs = {}
if isinstance(inputs, Trajectory):
# extract the variables
self.inputs = inputs.variables
elif isinstance(inputs, Variable):
self.inputs = {inputs.name: inputs}
elif isinstance(inputs, Pointset):
# turn into Variables with linear interpoolation between
# independent variable values
for n in inputs.coordnames:
x_array = inputs[n]
self.inputs[n] = Variable(interp1d(inputs.indepvararray,
x_array), 't',
Interval(n, 'float', extent(x_array)),
name=n)
elif isinstance(inputs, dict):
self.inputs = inputs
# ensure values are Variables or Pointsets
for k, v in self.inputs.iteritems():
if not isinstance(v, Variable):
try:
self.inputs[k]=Variable(v)
except:
raise TypeError, "Invalid specification of inputs"
else:
raise TypeError, "Invalid specification of inputs"
for v in self.inputs.values():
if not iscontinuous(v):
raise ValueError, \
("External inputs for ODE system must be "
"continuously defined")
fs_args['inputs'] = self.inputs.keys()
self._register(self.inputs)
self.foundKeys += 1
self._extInputsChanged = True
else:
self.inputs = {}
self._extInputsChanged = False
if 'ics' in kw:
self._xdatadict = {}
for k, v in dict(kw['ics']).iteritems():
self._xdatadict[str(k)] = v
self.initialconditions = self._xdatadict
for name in remain(varspecs.keys(),
self._xdatadict.keys()):
self.initialconditions[name] = NaN
self.foundKeys += 1
else:
self._xdatadict = {}
for name in varspecs:
self.initialconditions[name] = NaN
if 'auxvars' in kw:
assert 'vars' not in kw, ("Cannot use both 'auxvars' and 'vars' "
"keywords")
if isinstance(kw['auxvars'], list):
auxvars = [str(v) for v in kw['auxvars']]
else:
auxvars = [str(kw['auxvars'])]
vars = remain(varspecs.keys(), auxvars)
self.foundKeys += 1
elif 'vars' in kw:
assert 'auxvars' not in kw, \
"Cannot use both 'auxvars' and 'vars' keywords"
if isinstance(kw['vars'], list):
vars = [str(v) for v in kw['vars']]
else:
vars = [str(kw['vars'])]
auxvars = remain(varspecs.keys(), vars)
self.foundKeys += 1
else:
auxvars = []
vars = varspecs.keys()
if auxvars != []:
fs_args['auxvars'] = auxvars
if 'xdomain' in kw:
self._xdomain = {}
for k, v in dict(kw['xdomain']).iteritems():
name = str(k)
if type(v) in [list, Array, NArray]:
assert len(v) == 2, \
"Invalid size of domain specification for "+name
if v[0] >= v[1]:
raise PyDSTool_ValueError('xdomain values must be in'
'order of increasing size')
else:
self._xdomain[name] = copy(v)
elif type(v) in [float, int]:
self._xdomain[name] = [v, v]
else:
raise PyDSTool_TypeError('Invalid type for xdomain spec'
' '+name)
for name in remain(varspecs.keys(), self._xdomain.keys()):
self._xdomain[name] = [-Inf, Inf]
self.foundKeys += 1
else:
self._xdomain = {}
for name in varspecs:
self._xdomain[name] = [-Inf, Inf]
if 'reuseterms' in kw:
fs_args['reuseterms'] = kw['reuseterms']
self.foundKeys += 1
fs_args.update({'vars': vars,
'varspecs': varspecs,
'name': self.name
})
if 'algparams' in kw:
self._algparams = copy(kw['algparams'])
self.foundKeys += 1
else:
self._algparams = {}
if 'pars' in kw:
self.pars = {}
if type(kw['pars']) == list:
# may be a list of symbolic definitions
for p in kw['pars']:
try:
self.pars[p.name] = p.tonumeric()
except (AttributeError, TypeError):
raise TypeError, "Invalid parameter symbolic definition"
else:
for k, v in dict(kw['pars']).iteritems():
self.pars[str(k)] = v
fs_args['pars'] = self.pars.keys()
self._register(self.pars)
self.foundKeys += 1
if 'pdomain' in kw:
if self.pars:
self._pdomain = {}
for k, v in dict(kw['pdomain']).iteritems():
assert len(v) == 2, \
"Invalid size of domain specification for "+k
self._pdomain[str(k)] = v
for name in self._pdomain:
if self._pdomain[name][0] >= self._pdomain[name][1]:
raise PyDSTool_ValueError('pdomain values must be in order of increasing size')
for name in remain(self.pars.keys(), self._pdomain.keys()):
self._pdomain[name] = [-Inf, Inf]
self.foundKeys += 1
else:
raise ValueError('Cannot specify pdomain because no pars declared')
else:
if self.pars:
self._pdomain = {}
for pname in self.pars:
self._pdomain[pname] = [-Inf, Inf]
if self.pars:
self.parameterDomains = {}
for pname in self._pdomain:
self.parameterDomains[pname] = Interval(pname, 'float',
self._pdomain[pname],
self._abseps)
try:
cval = self.parameterDomains[pname].contains(self.pars[pname])
except KeyError:
raise ValueError("Parameter %s is missing a value"%pname)
if self.checklevel < 3:
if cval is not notcontained:
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 uncertain:
raise PyDSTool_UncertainValueError, 'Parameter value at bound'
elif cval is notcontained:
raise PyDSTool_ValueError, 'Parameter value out of bounds'
if 'fnspecs' in kw:
fs_args['fnspecs'] = ensureStrArgDict(kw['fnspecs'])
self.foundKeys += 1
fs_args['targetlang'] = theGenSpecHelper(self).lang
if 'compiler' in kw:
if fs_args['targetlang'] == 'python':
print "Warning: redundant option 'compiler' for python target"
self._compiler = kw['compiler']
self.foundKeys += 1
else:
osname = os.name
# os-specific defaults for C compiler
if osname == 'nt':
self._compiler = 'mingw32'
elif osname == 'mac':
self._compiler = 'mwerks'
elif osname == 'posix' or osname == 'unix':
self._compiler = 'unix'
elif osname == 'os2emx':
self._compiler = 'emx'
else:
self._compiler = ''
if 'vfcodeinsert_start' in kw:
fs_args['codeinsert_start'] = kw['vfcodeinsert_start']
self.foundKeys += 1
if 'vfcodeinsert_end' in kw:
fs_args['codeinsert_end'] = kw['vfcodeinsert_end']
self.foundKeys += 1
self.funcspec = RHSfuncSpec(fs_args)
# Holder and interface for events
self.eventstruct = EventStruct()
if 'enforcebounds' in kw:
if 'activatedbounds' in kw:
ab = kw['activatedbounds']
self.foundKeys += 1
else:
ab = None
if kw['enforcebounds']:
self._makeBoundsEvents(precise=True, activatedbounds=ab)
self.foundKeys += 1
if 'events' in kw:
self._addEvents(kw['events'])
self.foundKeys += 1
self.checkArgs(kw)
self.numpars = len(self.pars)
tindepdomain = Interval('t_domain', 'float', self._tdomain,
self._abseps)
tdepdomain = Interval('t', 'float', self._tdata, self._abseps)
self.indepvariable = Variable(listid, tindepdomain, tdepdomain, 't')
self._register(self.indepvariable)
self.dimension = len(self.funcspec.vars)
for xname in self.funcspec.vars + self.funcspec.auxvars:
# Add a temporary dependent variable domain, for validation testing
# during integration
self.variables[xname] = Variable(indepdomain=tdepdomain,
depdomain=Interval(xname, 'float',
self._xdomain[xname],
self._abseps))
self._register(self.variables)
self._generate_ixmaps()
# Introduce any python-specified code to the local namespace
if fs_args['targetlang'] == 'python':
self.addMethods()
# all registration completed
self.validateSpec()
def __init__(self, kw):
ctsGen.__init__(self, kw)
raise NotImplementedError
def __init__(self, kw):
try:
self.tdata = kw['tdata']
self._xdatadict = {}
for k, v in dict(kw['ics']).iteritems():
self._xdatadict[str(k)] = v
self.foundKeys = 2
# check for other, invalid keys (but currently just ignored)
except KeyError:
raise PyDSTool_KeyError('Keywords missing in argument')
if 'npts' in kw:
self.npts = kw['npts']
if self.npts is None:
self.npts = -1
self.foundKeys +=1
else:
self.npts = -1
tlen = len(self.tdata)
if self.npts > 1:
lidx = min(tlen,self.npts)
if lidx <= 1 or lidx == tlen:
tl = self.tdata
th = self.tdata
else:
tl = self.tdata[0:lidx]
th = self.tdata[-lidx-1:-1]
else:
tl = self.tdata
th = self.tdata
lidx = -1
self._lapx = {}
self._hapx = {}
for x in self._xdatadict:
if lidx > 1:
self._lapx[x] = polyfit(tl, self._xdatadict[x][0:lidx], 1)
self._hapx[x] = polyfit(th, self._xdatadict[x][-lidx-1:-1], 1)
else:
self._lapx[x] = polyfit(tl, self._xdatadict[x], 1)
self._hapx[x] = self._lapx[x]
if 'lotime' in kw:
assert kw['lotime'] < self.tdata[0]
loT = kw['lotime']
for x in self._xdatadict:
if tlen == 1:
newloval = self._xdatadict[x][0]
else:
newloval = self._lapx[x][0]*loT + self._xdatadict[x][0]
#newloval = (self._xdatadict[x][1] - self._xdatadict[x][0])/(self.tdata[1] - self.tdata[0])*loT
#+ self._xdatadict[x][0]
if isinstance(self._xdatadict[x], list):
self._xdatadict[x] = [newloval] + self._xdatadict[x]
else:
temp = self._xdatadict[x].tolist()
self._xdatadict[x] = array([newloval] + temp)
self.foundKeys += 1
if 'hitime' in kw:
assert kw['hitime'] > self.tdata[-1]
hiT = kw['hitime']
for x in self._xdatadict:
if tlen == 1:
newhival = self._xdatadict[x][-1]
else:
newhival = self._hapx[x][0]*hiT + self._xdatadict[x][-1]
#newhival = (self._xdatadict[x][-2] - self._xdatadict[x][-1])/(self.tdata[-2] - self.tdata[-1])*hiT
#+ self._xdatadict[x][-1]
if isinstance(self._xdatadict[x], list):
self._xdatadict[x] = self._xdatadict[x] + [newhival]
else:
temp = self._xdatadict[x].tolist()
self._xdatadict[x] = array(temp + [newhival])
self.foundKeys += 1
if 'lotime' in kw:
if isinstance(self.tdata, list):
self.tdata = [kw['lotime']] + self.tdata
else:
temp = self.tdata.tolist()
self.tdata = [kw['lotime']] + temp
if 'hitime' in kw:
if isinstance(self.tdata, list):
self.tdata = self.tdata + [kw['hitime']]
else:
temp = self.tdata.tolist()
self.tdata = temp + [kw['hitime']]
self.tdata = array(self.tdata)
self.tdomain = extent(self.tdata)
self.xdomain = {}
for x in self._xdatadict:
self.xdomain[x] = extent(self._xdatadict[x])
ctsGen.__init__(self, kw)
self.funcspec = {}
if 'vars' in kw:
raise PyDSTool_KeyError('vars option invalid for extrapolated table class')
if 'auxvars' in kw:
raise PyDSTool_KeyError('auxvars option invalid for extrapolated table class')
if 'tdomain' in kw:
raise PyDSTool_KeyError('tdomain option invalid for extrapolated table class')
if 'xdomain' in kw:
raise PyDSTool_KeyError('xdomain option invalid for extrapolated table class')
if 'pdomain' in kw:
raise PyDSTool_KeyError('pdomain option invalid for extrapolated table class')
if 'ttype' in kw:
raise PyDSTool_KeyError('ttype option invalid for extrapolated table class')
# hack to allow xtype to run
kw['varspecs'] = {}.fromkeys(self._xdatadict, '')
self._kw_process_dispatch(['varspecs', 'xtype'], kw)
del kw['varspecs']
self.foundKeys -= 1
if 'method' in kw:
if kw['method']=='linear':
interp=interp1d
elif kw['method']=='constant':
interp=interp0d
else:
raise ValueError("Invalid interpolation method")
self.foundKeys += 1
else:
# default to piecewise linear interpolation
interp=interp1d
for x in self._xdatadict:
self.funcspec[x] = Pointset({'coordarray': self._xdatadict[x],
'coordtype': float64,
'indepvararray': self.tdata,
'indepvartype': float64,
'indepvarname': 't',
'coordnames': x})
self._needKeys.extend(['tdata', 'ics'])
self._optionalKeys.extend(['method','lotime','hitime','npts'])
self.indepvartype = float
self.checkArgs(kw)
self.indepvariable = Variable(listid, Interval('t_domain',
self.indepvartype,
self.tdomain, self._abseps),
Interval('t', self.indepvartype,
extent(self.tdata),
self._abseps), 't')
self._register(self.indepvariable)
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)
self._register(self.variables)
self.dimension = len(self._xdatadict)
self.validateSpec()
self.defined = True
def __init__(self, kw):
ctsGen.__init__(self, kw)
self.needKeys.extend(['varspecs', 'ics'])
self.optionalKeys.extend([
'tdomain', 'pars', 'pdomain', 'xdomain', 'auxvars', 'vars',
'events', 'algparams', 'fnspecs', 'tdata'
])
fs_args = {}
if 'varspecs' in kw:
self.foundKeys += 1
varspecs = ensureStrArgDict(kw['varspecs'])
else:
raise PyDSTool_KeyError("Keyword 'varspecs' missing in argument")
if 'tdomain' in kw:
self._tdomain = kw['tdomain']
self.foundKeys += 1
else:
self._tdomain = [-Inf, Inf]
if 'tdata' in kw:
self._tdata = kw['tdata']
# _tdata is made into list to be consistent with
# other uses of it in other Dynamical Systems...
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\n'\
' 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\n'\
' from\n ', self._tdata[1], 'to', self._tdomain[1],\
'(difference of', self._tdata[1]-self._tdomain[1], ')'
self._tdata[1] = self._tdomain[1]
self.foundKeys += 1
else:
self._tdata = self._tdomain # default needed
if 'inputs' in kw:
raise PyDSTool_KeyError, 'inputs option invalid for ImplicitFnGen class'
if 'xdomain' in kw:
self._xdomain = {}
for k, v in dict(kw['xdomain']).iteritems():
name = str(k)
if type(v) in [list, Array, NArray]:
assert len(v) == 2, \
"Invalid size of domain specification for "+name
if v[0] >= v[1]:
raise PyDSTool_ValueError('xdomain values must be in'
'order of increasing size')
else:
self._xdomain[name] = copy(v)
elif type(v) in [float, int]:
self._xdomain[name] = [v, v]
else:
raise PyDSTool_TypeError('Invalid type for xdomain spec'
' ' + name)
for name in remain(varspecs.keys(), self._xdomain.keys()):
self._xdomain[name] = [-Inf, Inf]
self.foundKeys += 1
else:
self._xdomain = {}
for name in varspecs:
self._xdomain[name] = [-Inf, Inf]
if 'ics' in kw:
self._xdatadict = {}
for k, v in dict(kw['ics']).iteritems():
self._xdatadict[str(k)] = v
# initial condition for implicit function solver algorithm
self.initialconditions = self._xdatadict
for name in remain(varspecs.keys(), self._xdatadict.keys()):
self.initialconditions[name] = NaN
self.foundKeys += 1
if 'auxvars' in kw:
assert 'vars' not in kw, \
"Cannot use both 'auxvars' and 'vars' keywords"
if isinstance(kw['auxvars'], list):
auxvars = [str(v) for v in kw['auxvars']]
else:
auxvars = [str(kw['auxvars'])]
vars = remain(varspecs.keys(), auxvars)
self.foundKeys += 1
elif 'vars' in kw:
assert 'auxvars' not in kw, \
"Cannot use both 'auxvars' and 'vars' keywords"
if isinstance(kw['vars'], list):
vars = [str(v) for v in kw['vars']]
else:
vars = [str(kw['vars'])]
auxvars = remain(varspecs.keys(), vars)
self.foundKeys += 1
else:
auxvars = []
vars = remain(self._xdomain.keys(), auxvars)
if auxvars != []:
fs_args['auxvars'] = auxvars
fs_args.update({'vars': vars, 'varspecs': varspecs, 'name': self.name})
if 'pars' in kw:
self.pars = {}
if type(kw['pars']) == list:
# may be a list of symbolic definitions
for p in kw['pars']:
try:
self.pars[p.name] = p.tonumeric()
except (AttributeError, TypeError):
raise TypeError, "Invalid parameter symbolic definition"
else:
for k, v in dict(kw['pars']).iteritems():
self.pars[str(k)] = v
fs_args['pars'] = self.pars.keys()
self.foundKeys += 1
if 'pdomain' in kw:
if self.pars:
self._pdomain = {}
for k, v in dict(kw['pdomain']).iteritems():
assert len(v) == 2, \
"Invalid size of domain specification for "+k
self._pdomain[str(k)] = v
for name in self._pdomain:
if self._pdomain[name][0] >= self._pdomain[name][1]:
raise PyDSTool_ValueError(
'pdomain values must be in order of increasing size'
)
for name in remain(self.pars.keys(), self._pdomain.keys()):
self._pdomain[name] = [-Inf, Inf]
self.foundKeys += 1
else:
raise ValueError(
'Cannot specify pdomain because no pars declared')
else:
if self.pars:
self._pdomain = {}
for pname in self.pars:
self._pdomain[pname] = [-Inf, Inf]
if self.pars:
self.parameterDomains = {}
for pname in self._pdomain:
self.parameterDomains[pname] = Interval(
pname, 'float', self._pdomain[pname], self._abseps)
try:
cval = self.parameterDomains[pname].contains(
self.pars[pname])
except KeyError:
raise ValueError("Parameter %s is missing a value" % pname)
if self.checklevel < 3:
if cval is not notcontained:
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 uncertain:
raise PyDSTool_UncertainValueError, 'Parameter value at bound'
elif cval is notcontained:
raise PyDSTool_ValueError, 'Parameter value out of bounds'
if 'fnspecs' in kw:
fs_args['fnspecs'] = ensureStrArgDict(kw['fnspecs'])
self.foundKeys += 1
fs_args['targetlang'] = 'python'
self.funcspec = ImpFuncSpec(fs_args)
for s in self.funcspec.spec[0]:
if s.find('x[') > -1:
raise ValueError(
'Variable values cannot depend on '
'other variables in implicit function specs -- '
'in function:\n' + s)
if 'algparams' in kw:
self._algparams = copy(kw['algparams'])
self.foundKeys += 1
else:
self._algparams = {}
if 'solvemethod' in self._algparams:
if self._algparams['solvemethod'] not in _implicitSolveMethods:
raise PyDSTool_ValueError, 'Invalid implicit solver type'
# Holder and interface for events
self.eventstruct = EventStruct()
if 'events' in kw:
raise PyDSTool_ValueError('ImplicitFnGen does not presently' \
' support events')
## self._addEvents(kw['events'])
## assert self.eventstruct.getLowLevelEvents() == [], \
## "Can only pass high level events to ImplicitFnGen objects"
## assert self.eventstruct.query(['highlevel', 'varlinked']) == [], \
## "Only non-variable linked events are valid for this class"
## self.foundKeys += 1
self.checkArgs(kw)
if self.pars: # is defined
self._register(self.pars)
self.numpars = len(self.pars)
else:
self.numpars = 0
assert self.funcspec.targetlang == 'python', \
('Wrong target language for functional specification. '
'Python needed for this class')
self.newTempVars()
self._generate_ixmaps()
self.dimension = len(self.funcspec.vars)
def __init__(self, kw):
ctsGen.__init__(self, kw)
self.needKeys.extend(['varspecs', 'ics'])
self.optionalKeys.extend(['tdomain', 'pars', 'pdomain', 'xdomain',
'auxvars', 'vars', 'events',
'algparams', 'fnspecs', 'tdata'])
fs_args = {}
if 'varspecs' in kw:
self.foundKeys += 1
varspecs = ensureStrArgDict(kw['varspecs'])
else:
raise PyDSTool_KeyError("Keyword 'varspecs' missing in argument")
if 'tdomain' in kw:
self._tdomain = kw['tdomain']
self.foundKeys += 1
else:
self._tdomain = [-Inf, Inf]
if 'tdata' in kw:
self._tdata = kw['tdata']
# _tdata is made into list to be consistent with
# other uses of it in other Dynamical Systems...
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\n'\
' 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\n'\
' from\n ', self._tdata[1], 'to', self._tdomain[1],\
'(difference of', self._tdata[1]-self._tdomain[1], ')'
self._tdata[1] = self._tdomain[1]
self.foundKeys += 1
else:
self._tdata = self._tdomain # default needed
if 'inputs' in kw:
raise PyDSTool_KeyError, 'inputs option invalid for ImplicitFnGen class'
if 'xdomain' in kw:
self._xdomain = {}
for k, v in dict(kw['xdomain']).iteritems():
name = str(k)
if type(v) in [list, Array, NArray]:
assert len(v) == 2, \
"Invalid size of domain specification for "+name
if v[0] >= v[1]:
raise PyDSTool_ValueError('xdomain values must be in'
'order of increasing size')
else:
self._xdomain[name] = copy(v)
elif type(v) in [float, int]:
self._xdomain[name] = [v, v]
else:
raise PyDSTool_TypeError('Invalid type for xdomain spec'
' '+name)
for name in remain(varspecs.keys(), self._xdomain.keys()):
self._xdomain[name] = [-Inf, Inf]
self.foundKeys += 1
else:
self._xdomain = {}
for name in varspecs:
self._xdomain[name] = [-Inf, Inf]
if 'ics' in kw:
self._xdatadict = {}
for k, v in dict(kw['ics']).iteritems():
self._xdatadict[str(k)] = v
# initial condition for implicit function solver algorithm
self.initialconditions = self._xdatadict
for name in remain(varspecs.keys(),
self._xdatadict.keys()):
self.initialconditions[name] = NaN
self.foundKeys += 1
if 'auxvars' in kw:
assert 'vars' not in kw, \
"Cannot use both 'auxvars' and 'vars' keywords"
if isinstance(kw['auxvars'], list):
auxvars = [str(v) for v in kw['auxvars']]
else:
auxvars = [str(kw['auxvars'])]
vars = remain(varspecs.keys(), auxvars)
self.foundKeys += 1
elif 'vars' in kw:
assert 'auxvars' not in kw, \
"Cannot use both 'auxvars' and 'vars' keywords"
if isinstance(kw['vars'], list):
vars = [str(v) for v in kw['vars']]
else:
vars = [str(kw['vars'])]
auxvars = remain(varspecs.keys(), vars)
self.foundKeys += 1
else:
auxvars = []
vars = remain(self._xdomain.keys(), auxvars)
if auxvars != []:
fs_args['auxvars'] = auxvars
fs_args.update({'vars': vars,
'varspecs': varspecs,
'name': self.name
})
if 'pars' in kw:
self.pars = {}
if type(kw['pars']) == list:
# may be a list of symbolic definitions
for p in kw['pars']:
try:
self.pars[p.name] = p.tonumeric()
except (AttributeError, TypeError):
raise TypeError, "Invalid parameter symbolic definition"
else:
for k, v in dict(kw['pars']).iteritems():
self.pars[str(k)] = v
fs_args['pars'] = self.pars.keys()
self.foundKeys += 1
if 'pdomain' in kw:
if self.pars:
self._pdomain = {}
for k, v in dict(kw['pdomain']).iteritems():
assert len(v) == 2, \
"Invalid size of domain specification for "+k
self._pdomain[str(k)] = v
for name in self._pdomain:
if self._pdomain[name][0] >= self._pdomain[name][1]:
raise PyDSTool_ValueError('pdomain values must be in order of increasing size')
for name in remain(self.pars.keys(), self._pdomain.keys()):
self._pdomain[name] = [-Inf, Inf]
self.foundKeys += 1
else:
raise ValueError('Cannot specify pdomain because no pars declared')
else:
if self.pars:
self._pdomain = {}
for pname in self.pars:
self._pdomain[pname] = [-Inf, Inf]
if self.pars:
self.parameterDomains = {}
for pname in self._pdomain:
self.parameterDomains[pname] = Interval(pname, 'float',
self._pdomain[pname],
self._abseps)
try:
cval = self.parameterDomains[pname].contains(self.pars[pname])
except KeyError:
raise ValueError("Parameter %s is missing a value"%pname)
if self.checklevel < 3:
if cval is not notcontained:
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 uncertain:
raise PyDSTool_UncertainValueError, 'Parameter value at bound'
elif cval is notcontained:
raise PyDSTool_ValueError, 'Parameter value out of bounds'
if 'fnspecs' in kw:
fs_args['fnspecs'] = ensureStrArgDict(kw['fnspecs'])
self.foundKeys += 1
fs_args['targetlang'] = 'python'
self.funcspec = ImpFuncSpec(fs_args)
for s in self.funcspec.spec[0]:
if s.find('x[') > -1:
raise ValueError('Variable values cannot depend on '
'other variables in implicit function specs -- '
'in function:\n'+s)
if 'algparams' in kw:
self._algparams = copy(kw['algparams'])
self.foundKeys += 1
else:
self._algparams = {}
if 'solvemethod' in self._algparams:
if self._algparams['solvemethod'] not in _implicitSolveMethods:
raise PyDSTool_ValueError, 'Invalid implicit solver type'
# Holder and interface for events
self.eventstruct = EventStruct()
if 'events' in kw:
raise PyDSTool_ValueError('ImplicitFnGen does not presently' \
' support events')
## self._addEvents(kw['events'])
## assert self.eventstruct.getLowLevelEvents() == [], \
## "Can only pass high level events to ImplicitFnGen objects"
## assert self.eventstruct.query(['highlevel', 'varlinked']) == [], \
## "Only non-variable linked events are valid for this class"
## self.foundKeys += 1
self.checkArgs(kw)
if self.pars: # is defined
self._register(self.pars)
self.numpars = len(self.pars)
else:
self.numpars = 0
assert self.funcspec.targetlang == 'python', \
('Wrong target language for functional specification. '
'Python needed for this class')
self.newTempVars()
self._generate_ixmaps()
self.dimension = len(self.funcspec.vars)
