예제 #1
0
 def __init__(self, kw):
     discGen.__init__(self, kw)
     self._errmessages[E_COMPUTFAIL] = "Computation of trajectory failed"
     self.needKeys.extend(["varspecs"])
     self.optionalKeys.extend(
         [
             "tdomain",
             "xdomain",
             "inputs",
             "tdata",
             "ics",
             "events",
             "system",
             "ignorespecial",  #'compiler',
             "auxvars",
             "vars",
             "fnspecs",
             "ttype",
             "xtype",
             "tstep",
             "checklevel",
             "pars",
             "pdomain",
             "vfcodeinsert_start",
             "vfcodeinsert_end",
             "enforcebounds",
             "activatedbounds",
             "reuseterms",
         ]
     )
     fs_args = {}
     if "varspecs" in kw:
         self.foundKeys += 1
         varspecs = ensureStrArgDict(kw["varspecs"])
     else:
         raise PyDSTool_KeyError("Keyword 'varspecs' missing from " "argument")
     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 "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
     if "system" in kw:
         self._solver = kw["system"]
         try:
             fs_args["ignorespecial"] = [self._solver.name]
         except:
             raise TypeError, "Invalid solver system provided"
         self.foundKeys += 1
         if self.pars:
             # automatically pass par values on to embedded system
             # when Rhs called
             parlist = self.pars.keys()
             parstr = "".join(["'%s': %s, " % (parname, parname) for parname in parlist])
         if "codeinsert_start" in fs_args:
             fs_args["codeinsert_start"] = (
                 "    %s.set(pars={%s})\n" % (self._solver.name, parstr) + fs_args["codeinsert_start"]
             )
         else:
             fs_args["codeinsert_start"] = "    %s.set(pars={%s})\n" % (self._solver.name, parstr)
     else:
         fs_args["ignorespecial"] = []
         self._solver = None
     if "ignorespecial" in kw:
         fs_args["ignorespecial"].extend(kw["ignorespecial"])
         self.foundKeys += 1
     if "tdomain" in kw:
         self._tdomain = kw["tdomain"]
         if 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 "ttype" in kw:
         indepvartype = kw["ttype"]
         assert indepvartype in _pynametype.keys(), "Invalid ttype"
         self.foundKeys += 1
     else:
         indepvartype = "float"
     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
             ], ")"
             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 "tstep" in kw:
         self.tstep = kw["tstep"]
         if self.tstep > self._tdata[1] - self._tdata[0]:
             raise PyDSTool_ValueError("tstep too large")
         if indepvartype == "int" and round(self.tstep) != self.tstep:
             raise PyDSTool_ValueError("tstep must be an integer for integer ttype")
         self.foundKeys += 1
     else:
         if indepvartype == "int":
             # default to 1 for integer types
             self.tstep = 1
         else:
             # no reasonable default - so raise error
             raise PyDSTool_KeyError("tstep key needed for float ttype")
     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 but only define at Pointset's
             # own independent variable values
             self.inputs = dict(zip(inputs.coordnames, [Variable(inputs[[n]], name=n) for n in inputs.coordnames]))
         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"
         # don't check that variables have discrete domains in case wish
         # to use cts-valued ones sampled at discrete times
         fs_args["inputs"] = self.inputs.keys()
         self._register(self.inputs)
         self.foundKeys += 1
     else:
         self.inputs = {}
     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 "xtype" in kw:
         depvartype = kw["xtype"]
         assert depvartype in _pynametype.keys(), "Invalid xtype"
         self.foundKeys += 1
     else:
         depvartype = "float"
     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 "pdomain" in kw:
         if self.pars:
             self._pdomain = {}
             for k, v in dict(kw["pdomain"]).iteritems():
                 assert len(v) == 2, "Invalid interval for parameter %s" % 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'
     ##        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:
     ##            self._compiler = ''
     ##        if fs_args['targetlang'] != 'python' and inputs:
     ##            raise PyDSTool_ValueError('Cannot use external inputs with non-Python target language')
     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=False, 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", indepvartype, self._tdomain, self._abseps)
     tdepdomain = Interval("t", indepvartype, 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, depvartype, 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()
예제 #2
0
 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()
예제 #3
0
    def __init__(self, kw):
        discGen.__init__(self, kw)
        self._errmessages[E_COMPUTFAIL] = 'Computation of trajectory failed'
        self.needKeys.extend(['varspecs'])
        self.optionalKeys.extend(['tdomain', 'xdomain', 'inputs', 'tdata',
                          'ics', 'events', 'system', 'ignorespecial', #'compiler',
                          'auxvars', 'vars', 'fnspecs', 'ttype', 'xtype',
                          'tstep', 'checklevel', 'pars', 'pdomain',
                          'vfcodeinsert_start', 'vfcodeinsert_end',
                          'enforcebounds', 'activatedbounds', 'reuseterms'])
        fs_args = {}
        if 'varspecs' in kw:
            self.foundKeys += 1
            varspecs = ensureStrArgDict(kw['varspecs'])
        else:
            raise PyDSTool_KeyError("Keyword 'varspecs' missing from "
                                    "argument")
        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 '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
        if 'system' in kw:
            self._solver = kw['system']
            try:
                fs_args['ignorespecial'] = [self._solver.name]
            except:
                raise TypeError, "Invalid solver system provided"
            self.foundKeys += 1
            if self.pars:
                # automatically pass par values on to embedded system
                # when Rhs called
                parlist = self.pars.keys()
                parstr = "".join(["'%s': %s, "%(parname,parname) \
                                  for parname in parlist])
            if 'codeinsert_start' in fs_args:
                fs_args['codeinsert_start'] = \
                    '    %s.set(pars={%s})\n'%(self._solver.name, parstr) \
                    + fs_args['codeinsert_start']
            else:
                fs_args['codeinsert_start'] = \
                    '    %s.set(pars={%s})\n'%(self._solver.name, parstr)
        else:
            fs_args['ignorespecial'] = []
            self._solver = None
        if 'ignorespecial' in kw:
            fs_args['ignorespecial'].extend(kw['ignorespecial'])
            self.foundKeys += 1
        if 'tdomain' in kw:
            self._tdomain = kw['tdomain']
            if 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 'ttype' in kw:
            indepvartype = kw['ttype']
            assert indepvartype in _pynametype.keys(), 'Invalid ttype'
            self.foundKeys += 1
        else:
            indepvartype = 'float'
        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], ')'
                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 'tstep' in kw:
            self.tstep = kw['tstep']
            if self.tstep > self._tdata[1]-self._tdata[0]:
                raise PyDSTool_ValueError('tstep too large')
            if indepvartype == 'int' and round(self.tstep) != self.tstep:
                raise PyDSTool_ValueError('tstep must be an integer for integer ttype')
            self.foundKeys += 1
        else:
            if indepvartype == 'int':
                # default to 1 for integer types
                self.tstep = 1
            else:
                # no reasonable default - so raise error
                raise PyDSTool_KeyError('tstep key needed for float ttype')
        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 but only define at Pointset's
                # own independent variable values
                self.inputs = dict(zip(inputs.coordnames,
                            [Variable(inputs[[n]],name=n) for n in inputs.coordnames]))
            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"
            # don't check that variables have discrete domains in case wish
            # to use cts-valued ones sampled at discrete times
            fs_args['inputs'] = self.inputs.keys()
            self._register(self.inputs)
            self.foundKeys += 1
        else:
            self.inputs = {}
        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 'xtype' in kw:
            depvartype = kw['xtype']
            assert depvartype in _pynametype.keys(), 'Invalid xtype'
            self.foundKeys += 1
        else:
            depvartype = 'float'
        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 'pdomain' in kw:
            if self.pars:
                self._pdomain = {}
                for k, v in dict(kw['pdomain']).iteritems():
                    assert len(v) == 2, "Invalid interval for parameter %s"%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'
##        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:
##            self._compiler = ''
##        if fs_args['targetlang'] != 'python' and inputs:
##            raise PyDSTool_ValueError('Cannot use external inputs with non-Python target language')
        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=False, 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', indepvartype, self._tdomain,
                                self._abseps)
        tdepdomain = Interval('t', indepvartype, 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, depvartype,
                                                          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()
예제 #4
0
    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)