def test_diagnostic_mode(self):
self.pest.diagnostic_mode = True
objval, thetavals = self.pest.theta_est()
asym = np.arange(10, 30, 2)
rate = np.arange(0, 1.5, 0.25)
theta_vals = pd.DataFrame(list(product(asym, rate)),
columns=self.pest.theta_names)
obj_at_theta = self.pest.objective_at_theta(theta_vals)
self.pest.diagnostic_mode = False
def test_likelihood_ratio(self):
objval, thetavals = self.pest.theta_est()
asym = np.arange(10, 30, 2)
rate = np.arange(0, 1.5, 0.25)
theta_vals = pd.DataFrame(list(product(asym, rate)),
columns=self.pest.theta_names)
obj_at_theta = self.pest.objective_at_theta(theta_vals)
LR = self.pest.likelihood_ratio_test(obj_at_theta, objval,
[0.8, 0.9, 1.0])
self.assertTrue(set(LR.columns) >= set([0.8, 0.9, 1.0]))
self.assertTrue(LR[0.8].sum() == 6)
self.assertTrue(LR[0.9].sum() == 10)
self.assertTrue(LR[1.0].sum() == 60) # all true
graphics.pairwise_plot(LR, thetavals, 0.8)
def simulate(self, numpoints=None, tstep=None, integrator=None,
varying_inputs=None, initcon=None, integrator_options=None):
"""
Simulate the model. Integrator-specific options may be specified as
keyword arguments and will be passed on to the integrator.
Parameters
----------
numpoints : int
The number of points for the profiles returned by the simulator.
Default is 100
tstep : int or float
The time step to use in the profiles returned by the simulator.
This is not the time step used internally by the integrators.
This is an optional parameter that may be specified in place of
'numpoints'.
integrator : string
The string name of the integrator to use for simulation. The
default is 'lsoda' when using Scipy and 'idas' when using CasADi
varying_inputs : ``pyomo.environ.Suffix``
A :py:class:`Suffix<pyomo.environ.Suffix>` object containing the
piecewise constant profiles to be used for certain time-varying
algebraic variables.
initcon : list of floats
The initial conditions for the the differential variables. This
is an optional argument. If not specified then the simulator
will use the current value of the differential variables at the
lower bound of the ContinuousSet for the initial condition.
integrator_options : dict
Dictionary containing options that should be passed to the
integrator. See the documentation for a specific integrator for a
list of valid options.
Returns
-------
numpy array, numpy array
The first return value is a 1D array of time points corresponding
to the second return value which is a 2D array of the profiles for
the simulated differential and algebraic variables.
"""
if not numpy_available:
raise ValueError("The numpy module is not available. "
"Cannot simulate the model.")
if integrator_options is None:
integrator_options = {}
if self._intpackage == 'scipy':
# Specify the scipy integrator to use for simulation
valid_integrators = ['vode', 'zvode', 'lsoda', 'dopri5', 'dop853']
if integrator is None:
integrator = 'lsoda'
elif integrator == 'odeint':
integrator = 'lsoda'
else:
# Specify the casadi integrator to use for simulation.
# Only a subset of these integrators may be used for
# DAE simulation. We defer this check to CasADi.
valid_integrators = ['cvodes', 'idas', 'collocation', 'rk']
if integrator is None:
integrator = 'idas'
if integrator not in valid_integrators:
raise DAE_Error("Unrecognized %s integrator \'%s\'. Please select"
" an integrator from %s" % (self._intpackage,
integrator,
valid_integrators))
# Set the time step or the number of points for the lists
# returned by the integrator
if tstep is not None and \
tstep > (self._contset.last() - self._contset.first()):
raise ValueError(
"The step size %6.2f is larger than the span of the "
"ContinuousSet %s" % (tstep, self._contset.name()))
if tstep is not None and numpoints is not None:
raise ValueError(
"Cannot specify both the step size and the number of "
"points for the simulator")
if tstep is None and numpoints is None:
# Use 100 points by default
numpoints = 100
if tstep is None:
tsim = np.linspace(
self._contset.first(), self._contset.last(), num=numpoints)
# Consider adding an option for log spaced time points. Can be
# important for simulating stiff systems.
# tsim = np.logspace(-4,6, num=100)
# np.log10(self._contset.first()),np.log10(
# self._contset.last()),num=1000, endpoint=True)
else:
tsim = np.arange(
self._contset.first(), self._contset.last(), tstep)
switchpts = []
self._siminputvars = {}
self._simalgvars = []
if varying_inputs is not None:
if type(varying_inputs) is not Suffix:
raise TypeError(
"Varying input values must be specified using a "
"Suffix. Please refer to the simulator documentation.")
for alg in self._algvars:
if alg._base in varying_inputs:
# Find all the switching points
switchpts += varying_inputs[alg._base].keys()
# Add to dictionary of siminputvars
self._siminputvars[alg._base] = alg
else:
self._simalgvars.append(alg)
if self._intpackage == 'scipy' and len(self._simalgvars) != 0:
raise DAE_Error("When simulating with Scipy you must "
"provide values for all parameters "
"and algebraic variables that are indexed "
"by the ContinuoutSet using the "
"'varying_inputs' keyword argument. "
"Please refer to the simulator documentation "
"for more information.")
# Get the set of unique points
switchpts = list(set(switchpts))
switchpts.sort()
# Make sure all the switchpts are within the bounds of
# the ContinuousSet
if switchpts[0] < self._contset.first() or \
switchpts[-1] > self._contset.last():
raise ValueError("Found a switching point for one or more of "
"the time-varying inputs that is not within "
"the bounds of the ContinuousSet.")
# Update tsim to include input switching points
# This numpy function returns the unique, sorted points
tsim = np.union1d(tsim, switchpts)
else:
self._simalgvars = self._algvars
# Check if initial conditions were provided, otherwise obtain
# them from the current variable values
if initcon is not None:
if len(initcon) > len(self._diffvars):
raise ValueError(
"Too many initial conditions were specified. The "
"simulator was expecting a list with %i values."
% len(self._diffvars))
if len(initcon) < len(self._diffvars):
raise ValueError(
"Too few initial conditions were specified. The "
"simulator was expecting a list with %i values."
% len(self._diffvars))
else:
initcon = []
for v in self._diffvars:
for idx, i in enumerate(v._args):
if type(i) is IndexTemplate:
break
initpoint = self._contset.first()
vidx = tuple(v._args[0:idx]) + (initpoint,) + \
tuple(v._args[idx + 1:])
# This line will raise an error if no value was set
initcon.append(value(v._base[vidx]))
# Call the integrator
if self._intpackage == 'scipy':
if not scipy_available:
raise ValueError("The scipy module is not available. "
"Cannot simulate the model.")
if is_pypy:
raise ValueError("The scipy ODE integrators do not work "
"under pypy. Cannot simulate the model.")
tsim, profile = self._simulate_with_scipy(initcon, tsim, switchpts,
varying_inputs,
integrator,
integrator_options)
else:
if len(switchpts) != 0:
tsim, profile = \
self._simulate_with_casadi_with_inputs(initcon, tsim,
varying_inputs,
integrator,
integrator_options)
else:
tsim, profile = \
self._simulate_with_casadi_no_inputs(initcon, tsim,
integrator,
integrator_options)
self._tsim = tsim
self._simsolution = profile
return [tsim, profile]
