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)