1 |
clausted |
17 |
"""
|
2 |
clausted |
53 |
mdl_module
|
3 |
|
|
-------------------------------------------------------------------------------
|
4 |
clausted |
17 |
|
5 |
clausted |
54 |
*Example model functions module for SPRI data.*
|
6 |
clausted |
53 |
Just a few simple, common interaction models will go here.
|
7 |
|
|
In the future, each new model will go in its own module/file.
|
8 |
clausted |
54 |
Each model is a function taking three parameters.
|
9 |
clausted |
53 |
|
10 |
clausted |
54 |
**Parameters:**
|
11 |
|
|
* *time* (numpy array) -- Time points, usually in seconds.
|
12 |
|
|
* *data* (numpy array) -- Initial SPR signal values.
|
13 |
|
|
* *params* (dictionary of dictionaries) -- Model parameter description.
|
14 |
|
|
|
15 |
|
|
**Returns:** numpy array of calculated SPR signal values.
|
16 |
|
|
|
17 |
clausted |
53 |
The dictionary keys are the names of model parameters
|
18 |
|
|
(e.g. 'rmax' for maximal response, or 'kon' for kinetic on-rate).
|
19 |
|
|
Each model parameter is described by a subdictionary containing four entries.
|
20 |
|
|
|
21 |
clausted |
54 |
* ``'value'`` The current value of the parameter.
|
22 |
|
|
* ``'min'`` The minimum allowable value.
|
23 |
|
|
* ``'max'`` The maximum allowable value.
|
24 |
|
|
* ``'fixed'`` Either 'float', 'fixed', or a reference to another ROI.
|
25 |
clausted |
53 |
|
26 |
clausted |
54 |
The ``min``, ``max``, and ``fixed`` keys are used during automatic curve-fitting.
|
27 |
clausted |
53 |
A fixed parameter is not allowed to change, while a float parameter is adjusted
|
28 |
|
|
until the least-squares algorithm has minimized the sum-squared error.
|
29 |
|
|
The *fixed* parameter may also be an integer, in which case it is fixed to
|
30 |
|
|
the value of a parameter of the same name in another ROI.
|
31 |
|
|
|
32 |
|
|
The model function returns an array of values obtained by numerical integration.
|
33 |
|
|
The model is represented by differential equations and integrated using the
|
34 |
|
|
rectangle rule or, preferentially, using the trapezoidal rule.
|
35 |
|
|
|
36 |
|
|
.. moduleauthor:: Christopher Lausted,
|
37 |
|
|
Institute for Systems Biology,
|
38 |
|
|
OSPRAI developers.
|
39 |
|
|
|
40 |
|
|
Examples::
|
41 |
|
|
|
42 |
|
|
>>> import mdl_module as mdl
|
43 |
|
|
>>> import numpy as np
|
44 |
clausted |
60 |
>>> times, data = np.arange(300), np.zeros(300)
|
45 |
clausted |
53 |
>>>
|
46 |
clausted |
60 |
>>> param1 = {'rate': {'value':1.0, 'min':-10.0, 'max':10.0, 'fixed':True} }
|
47 |
|
|
>>> data1 = mdl.drift(times, data, param1)
|
48 |
|
|
>>> print round(data1[299], 1)
|
49 |
|
|
299.0
|
50 |
|
|
>>> param1 = dict(rate=dict(value=-1.0, min=-10.0, max=10.0, fixed=True))
|
51 |
|
|
>>> data1 = mdl.drift(times, data, param1)
|
52 |
|
|
>>> print round(data1[299], 1)
|
53 |
|
|
-299.0
|
54 |
clausted |
53 |
>>>
|
55 |
clausted |
60 |
>>> param2 = mdl.simple1to1_def_params()
|
56 |
|
|
>>> param2['rmax'] ['value'] = 1000.0
|
57 |
|
|
>>> param2['conc']['value'] = 1e-6
|
58 |
|
|
>>> param2['t1']['value'] = 100
|
59 |
|
|
>>> param2['kon']['value'] = 1e4
|
60 |
|
|
>>> param2['t2']['value'] = 200.0
|
61 |
|
|
>>> param2['koff']['value'] = 1e-2
|
62 |
|
|
>>> param2['t3']['value'] = 300.0
|
63 |
|
|
>>> data2 = mdl.simple1to1(times, data, param2)
|
64 |
|
|
>>> print round(data2[299], 1)
|
65 |
|
|
160.3
|
66 |
clausted |
17 |
"""
|
67 |
clausted |
60 |
__version__ = "110517"
|
68 |
clausted |
17 |
|
69 |
|
|
|
70 |
|
|
## Import libraries
|
71 |
|
|
import numpy as np
|
72 |
clausted |
18 |
from copy import deepcopy
|
73 |
clausted |
17 |
|
74 |
|
|
|
75 |
clausted |
18 |
def drift(time, data, params):
|
76 |
clausted |
17 |
"""
|
77 |
|
|
This function simply models a constant signal drift in units/second.
|
78 |
clausted |
18 |
It requires numpy arrays of times and starting data values,
|
79 |
clausted |
17 |
It only requires one parameter in the params list.
|
80 |
clausted |
53 |
|
81 |
clausted |
54 |
``params['rate']['value']``
|
82 |
clausted |
17 |
"""
|
83 |
clausted |
18 |
y = np.zeros(len(time), dtype=float)
|
84 |
clausted |
17 |
try:
|
85 |
clausted |
18 |
rate = params['rate']['value']
|
86 |
clausted |
17 |
except KeyError:
|
87 |
|
|
print "Error: Rate parameter not supplied to drift() model."
|
88 |
clausted |
18 |
return y
|
89 |
clausted |
17 |
|
90 |
clausted |
18 |
## Numerical integration.
|
91 |
|
|
y[0] = data[0]
|
92 |
|
|
for i in range(1,len(time)):
|
93 |
|
|
dy = rate * (time[i]-time[i-1])
|
94 |
|
|
y[i] = y[i-1] + dy
|
95 |
|
|
|
96 |
|
|
return y
|
97 |
clausted |
19 |
## End of drift() function.
|
98 |
clausted |
18 |
|
99 |
clausted |
60 |
def drift_def_params():
|
100 |
|
|
""""
|
101 |
|
|
Return dictionary of default parameters for drift model::
|
102 |
|
|
|
103 |
|
|
>>> from numpy import arange, zeros
|
104 |
|
|
>>> defaultparam0 = drift_def_params()
|
105 |
|
|
>>> data0 = drift(arange(100), zeros(100), defaultparam0)
|
106 |
|
|
>>> print round(data0[99], 1)
|
107 |
|
|
99.0
|
108 |
|
|
"""
|
109 |
|
|
dpar = dict(rate=dict(value=1.0, min=-100.0, max=100.0, fixed=True))
|
110 |
|
|
return dpar
|
111 |
clausted |
18 |
|
112 |
clausted |
60 |
|
113 |
clausted |
18 |
def simple1to1(time, data, params):
|
114 |
|
|
"""
|
115 |
clausted |
26 |
This function simply models a 1:1 interaction.
|
116 |
clausted |
54 |
The model parameters are described in the table below.
|
117 |
clausted |
26 |
|
118 |
clausted |
53 |
Model::
|
119 |
clausted |
29 |
|
120 |
clausted |
53 |
[A] + [L] --kon--> [AL]
|
121 |
|
|
[A] + [L] <-koff-- [AL]
|
122 |
|
|
|
123 |
|
|
Derivation::
|
124 |
|
|
|
125 |
|
|
d[AL]/dt = kon*[A]*[L] - koff*[AL]
|
126 |
|
|
y = [AL]
|
127 |
|
|
(rmax-y) = [L]
|
128 |
|
|
conc = [A]
|
129 |
|
|
rmax = [AL] + [L]
|
130 |
|
|
dy/dt = conc*kon*(rmax-y) - koff*y
|
131 |
|
|
|
132 |
|
|
======================= ============================================
|
133 |
|
|
Model Parameter Description
|
134 |
|
|
======================= ============================================
|
135 |
|
|
params['t1']['value'] time of injection for binding, (s)
|
136 |
|
|
params['rmax']['value'] maximum response, (RIU)
|
137 |
|
|
params['conc']['value'] concentration of analyte [A], (M)
|
138 |
|
|
params['kon']['value'] on-rate of analyte, (1/Ms)
|
139 |
|
|
params['t2']['value'] time of end binding & begin washing, (s)
|
140 |
|
|
params['koff']['value'] off-rate of analyte, (1/s)
|
141 |
|
|
params['t3']['value'] time end of washing & data fitting, (s)
|
142 |
|
|
----------------------- --------------------------------------------
|
143 |
|
|
*Optional*
|
144 |
|
|
params['cofa']['value'] concentration factor, (1/dilution factor)
|
145 |
|
|
======================= ============================================
|
146 |
|
|
|
147 |
clausted |
18 |
"""
|
148 |
clausted |
53 |
|
149 |
clausted |
18 |
## Skip parameter validation steps for now.
|
150 |
clausted |
29 |
t1 = float(params['t1']['value'])
|
151 |
|
|
rmax = float(params['rmax']['value'])
|
152 |
|
|
conc = float(params['conc']['value'])
|
153 |
|
|
kon = float(params['kon']['value'])
|
154 |
|
|
t2 = float(params['t2']['value'])
|
155 |
|
|
koff = float(params['koff']['value'])
|
156 |
|
|
t3 = float(params['t3']['value'])
|
157 |
|
|
if ('cofa' in params.keys()):
|
158 |
|
|
conc *= float(params['cofa']['value'])
|
159 |
clausted |
55 |
|
160 |
|
|
## Initialize variables.
|
161 |
|
|
errlog = {} ## Error status dictionary.
|
162 |
clausted |
18 |
y = np.zeros(len(time), dtype=float)
|
163 |
|
|
base = y[0] = data[0] ## Baseline SPR signal.
|
164 |
|
|
|
165 |
|
|
## Must iterate through data, numerical integration.
|
166 |
|
|
for i in range(1,len(time)):
|
167 |
clausted |
26 |
dt = time[i] - time[i-1]
|
168 |
|
|
## Treat function as having three separate phases.
|
169 |
clausted |
18 |
if (time[i] <= t1):
|
170 |
|
|
## Pre-binding phase.
|
171 |
|
|
base = y[i] = data[i]
|
172 |
|
|
elif (t1 < time[i] <= t2):
|
173 |
|
|
## Binding phase
|
174 |
|
|
yb = y[i-1] - base
|
175 |
|
|
dy = conc*kon*(rmax-yb) - koff*yb
|
176 |
clausted |
26 |
y[i] = y[i-1] + dy*dt
|
177 |
clausted |
55 |
## Check if we overshot the maximum response.
|
178 |
|
|
if (y[i] > (base+rmax)):
|
179 |
|
|
y[i] = base+rmax
|
180 |
|
|
errlog['Response overshot rmax.'] = True
|
181 |
clausted |
18 |
elif (t2 < time[i] <= t3):
|
182 |
clausted |
26 |
## Dissociation (conc=0)
|
183 |
clausted |
18 |
yb = y[i-1]-base
|
184 |
|
|
dy = 0 - koff*yb
|
185 |
clausted |
26 |
y[i] = y[i-1] + dy*dt
|
186 |
clausted |
55 |
|
187 |
|
|
if any(errlog): print "Errors in simple1to1:", errlog.keys()
|
188 |
clausted |
18 |
|
189 |
|
|
return y
|
190 |
clausted |
53 |
"""End of simple1to1() function"""
|
191 |
clausted |
18 |
|
192 |
clausted |
60 |
def simple1to1_def_params():
|
193 |
|
|
""""
|
194 |
|
|
Return a dictionary of default parameters for simple1to1 model::
|
195 |
|
|
|
196 |
|
|
>>> from numpy import arange, zeros
|
197 |
|
|
>>> defaultparam0 = simple1to1_def_params()
|
198 |
|
|
>>> data0 = simple1to1(arange(300), zeros(300), defaultparam0)
|
199 |
|
|
>>> print round(data0[299], 1)
|
200 |
|
|
160.3
|
201 |
|
|
"""
|
202 |
|
|
dpar = {}
|
203 |
|
|
dpar['rmax'] = dict(value=1e3, min=1e1, max=1e4, fixed=True)
|
204 |
|
|
dpar['conc'] = dict(value=1e-6, min=1e-12, max=1e-1, fixed=True)
|
205 |
|
|
dpar['cofa'] = dict(value=1.0, min=1e-6, max=1e6, fixed=True)
|
206 |
|
|
dpar['t1'] = dict(value=100.0, min=100.0, max=100.0, fixed=True)
|
207 |
|
|
dpar['kon'] = dict(value=1e4, min=1e2, max=1e7, fixed=True)
|
208 |
|
|
dpar['t2'] = dict(value=200.0, min=200.0, max=200.0, fixed=True)
|
209 |
|
|
dpar['koff'] = dict(value=1e-2, min=1e-6, max=1e-1, fixed=True)
|
210 |
|
|
dpar['t3'] = dict(value=300.0, min=300.0, max=300.0, fixed=True)
|
211 |
|
|
return dpar
|
212 |
clausted |
19 |
|
213 |
clausted |
60 |
|
214 |
clausted |
26 |
def simple1to1_mtl(time, data, params):
|
215 |
|
|
"""
|
216 |
|
|
This function simply models a 1:1 interaction with mass transport limitation.
|
217 |
clausted |
54 |
The model parameters are described in the table below.
|
218 |
clausted |
26 |
|
219 |
clausted |
53 |
Model::
|
220 |
clausted |
29 |
|
221 |
clausted |
53 |
[Abulk] --km-> [Asurf] + [L] --kon--> [AL]
|
222 |
|
|
[Abulk] <-km-- [Asurf] + [L] <-koff-- [AL]
|
223 |
|
|
|
224 |
|
|
Derivation::
|
225 |
|
|
|
226 |
|
|
d[AL]/dt = (kon*[A]*[L] - koff*[AL]) / (1 + kon*[L]/kmtl)
|
227 |
|
|
y = [AL]
|
228 |
|
|
(rmax-y) = [L]
|
229 |
|
|
conc = [Abulk]
|
230 |
|
|
rmax = [AL] + [L]
|
231 |
|
|
dy/dt = (kon*conc*(rmax-y) - koff*y) / (1 + kon*(rmax-y)/kmtl)
|
232 |
|
|
|
233 |
|
|
======================= ============================================
|
234 |
|
|
Model Parameter Description
|
235 |
|
|
======================= ============================================
|
236 |
|
|
params['t1']['value'] time of injection for binding, (s)
|
237 |
|
|
params['rmax']['value'] maximum response, (RIU)
|
238 |
|
|
params['conc']['value'] concentration of analyte [Abulk], (M)
|
239 |
|
|
params['kon']['value'] on-rate of analyte, (1/Ms)
|
240 |
|
|
params['t2']['value'] time of end binding & begin washing, (s)
|
241 |
|
|
params['koff']['value'] off-rate of analyte, (1/s)
|
242 |
|
|
params['t3']['value'] time end of washing & data fitting, (s)
|
243 |
|
|
params['kmtl']['value'] rate of diffusion, (RIU/Ms)
|
244 |
|
|
----------------------- --------------------------------------------
|
245 |
|
|
*Optional*
|
246 |
|
|
params['cofa']['value'] concentration factor, (1/dilution factor)
|
247 |
|
|
======================= ============================================
|
248 |
|
|
|
249 |
clausted |
26 |
"""
|
250 |
clausted |
53 |
|
251 |
clausted |
26 |
## Skip parameter validation steps for now.
|
252 |
|
|
t1 = params['t1']['value']
|
253 |
|
|
rmax = params['rmax']['value']
|
254 |
|
|
conc = params['conc']['value']
|
255 |
|
|
kon = params['kon']['value']
|
256 |
|
|
t2 = params['t2']['value']
|
257 |
|
|
koff = params['koff']['value']
|
258 |
|
|
t3 = params['t3']['value']
|
259 |
|
|
kmtl = params['kmtl']['value']
|
260 |
clausted |
29 |
if ('cofa' in params.keys()):
|
261 |
|
|
conc *= float(params['cofa']['value'])
|
262 |
|
|
|
263 |
clausted |
53 |
## Initialize variables.
|
264 |
clausted |
55 |
errlog = {} ## Error status dictionary.
|
265 |
clausted |
26 |
y = np.zeros(len(time), dtype=float)
|
266 |
|
|
base = y[0] = data[0] ## Baseline SPR signal.
|
267 |
|
|
|
268 |
|
|
## Error checks.
|
269 |
|
|
if (kmtl<=0):
|
270 |
|
|
## Avoid div/0, assume user wants no mass transport limitation.
|
271 |
|
|
stat['kmtl must be > 0'] = True
|
272 |
|
|
kmtl = 1e40 ## An arbitrary very large number.
|
273 |
|
|
|
274 |
|
|
## Must iterate through data, numerical integration.
|
275 |
|
|
for i in range(1,len(time)):
|
276 |
|
|
dt = time[i] - time[i-1]
|
277 |
|
|
## Treat function as having three separate phases.
|
278 |
|
|
if (time[i] <= t1):
|
279 |
|
|
## Pre-binding phase.
|
280 |
|
|
base = y[i] = data[i]
|
281 |
|
|
elif (t1 < time[i] <= t2):
|
282 |
|
|
## Binding phase
|
283 |
|
|
yb = y[i-1] - base
|
284 |
|
|
dy = (conc*kon*(rmax-yb) - koff*yb) / (1 + kon*(rmax-yb)/kmtl)
|
285 |
|
|
y[i] = y[i-1] + dy*dt
|
286 |
clausted |
55 |
## Check if we overshot the maximum response.
|
287 |
|
|
if (y[i] > (base+rmax)):
|
288 |
|
|
y[i] = base+rmax
|
289 |
|
|
errlog['Response overshot rmax.'] = True
|
290 |
clausted |
26 |
elif (t2 < time[i] <= t3):
|
291 |
|
|
## Dissociation (conc=0)
|
292 |
|
|
yb = y[i-1] - base
|
293 |
|
|
dy = (0 - koff*yb) / (1 + kon*(rmax-yb)/kmtl)
|
294 |
|
|
y[i] = y[i-1] + dy*dt
|
295 |
|
|
|
296 |
clausted |
55 |
if any(errlog): print "Errors in simple1to1:", errlog.keys()
|
297 |
clausted |
26 |
|
298 |
|
|
return y
|
299 |
clausted |
53 |
"""End of simple1to1_mtl() function"""
|
300 |
clausted |
60 |
|
301 |
|
|
def simple1to1_mtl_def_params():
|
302 |
|
|
""""
|
303 |
|
|
Return dictionary of default parameters for simple1to1_mtl model::
|
304 |
|
|
|
305 |
|
|
>>> from numpy import arange, zeros
|
306 |
|
|
>>> defaultparam0 = simple1to1_mtl_def_params()
|
307 |
|
|
>>> data0 = simple1to1_mtl(arange(300), zeros(300), defaultparam0)
|
308 |
|
|
>>> print round(data0[299], 1)
|
309 |
|
|
161.1
|
310 |
|
|
|
311 |
|
|
"""
|
312 |
|
|
dpar = simple1to1_def_params() ## Based on simple1to1.
|
313 |
|
|
dpar['kmtl'] = dict(value=1e9, min=1e2, max=1e10, fixed=True)
|
314 |
|
|
return dpar
|
315 |
clausted |
26 |
|
316 |
|
|
|
317 |
clausted |
60 |
def simple1to1_series(time, data, params):
|
318 |
|
|
"""
|
319 |
|
|
Model up to 8 simple 1:1 SPR injections of varying concentration.
|
320 |
|
|
|
321 |
|
|
======================= ==========================================
|
322 |
|
|
Model Parameter Description
|
323 |
|
|
======================= ==========================================
|
324 |
|
|
params['kon']['value'] on-rate of analyte, (1/Ms)
|
325 |
|
|
params['koff']['value'] off-rate of analyte, (1/s)
|
326 |
|
|
params['rmax']['value'] maximum response, (RIU)
|
327 |
|
|
params['tp']['value'] time prior to binding, (s)
|
328 |
|
|
params['ta']['value'] time/duration of association, (s)
|
329 |
|
|
params['td']['value'] time/duration of dissociation, (s)
|
330 |
|
|
----------------------- ------------------------------------------
|
331 |
|
|
params['t0']['value'] timepoint of first (no.0) injection, (s)
|
332 |
|
|
... ...
|
333 |
|
|
params['t7']['value'] timepoint of eighth (no.7) injection, (s)
|
334 |
|
|
----------------------- ------------------------------------------
|
335 |
|
|
params['c0']['value'] concentration of first injection, (s)
|
336 |
|
|
... ...
|
337 |
|
|
params['c7']['value'] concentration of eighth injection, (s)
|
338 |
|
|
======================= ==========================================
|
339 |
|
|
|
340 |
|
|
Injections where tN=0 are ignored. For example, if you have only
|
341 |
|
|
six injections, set t6=0 and t7=0.
|
342 |
|
|
"""
|
343 |
|
|
|
344 |
|
|
## Parameters from params dictionary.
|
345 |
|
|
## Skip parameter validation steps for now.
|
346 |
|
|
kon = float(params['kon']['value'])
|
347 |
|
|
koff = float(params['koff']['value'])
|
348 |
|
|
rmax = float(params['rmax']['value'])
|
349 |
|
|
## Pre-association, Association duration, Dissociation duration.
|
350 |
|
|
tp = float(params['tp']['value']) ## Typical -100 s
|
351 |
|
|
ta = float(params['ta']['value']) ## Typical 300 s
|
352 |
|
|
td = float(params['td']['value']) ## Typical 300 s
|
353 |
|
|
td = td + ta ## After 300s binding and 300s washing, 600s elapse.
|
354 |
|
|
## How many injections are there? Check valid keys and inj times.
|
355 |
|
|
tkey = ['t0','t1','t2','t3','t4','t5','t6','t7']
|
356 |
|
|
ckey = ['c0','c1','c2','c3','c4','c5','c6','c7']
|
357 |
|
|
for i in range(8):
|
358 |
|
|
if (tkey[i] in params) and (ckey[i] in params):
|
359 |
|
|
## Valid inj time is after sufficient pre-association time.
|
360 |
|
|
if ((float(params[tkey[i]]['value']) + tp) > 0):
|
361 |
|
|
inj = i+1 ## Increase inj count.
|
362 |
|
|
## Up to eight injection start times, concentrations.
|
363 |
|
|
ti = [float(params[k]['value']) for k in tkey[0:inj]]
|
364 |
|
|
c = [float(params[k]['value']) for k in ckey[0:inj]]
|
365 |
|
|
|
366 |
|
|
## Begin.
|
367 |
|
|
y = np.zeros(len(time), dtype=float)
|
368 |
|
|
base = y[0] = data[0] ## Baseline SPR signal.
|
369 |
|
|
|
370 |
|
|
## Must iterate through data, numerical integration.
|
371 |
|
|
for i in range(1,len(time)):
|
372 |
|
|
dt = time[i] - time[i-1]
|
373 |
|
|
#if (time[i] > (max(ti)+td)): break ## Speed things up.
|
374 |
|
|
inmodel = False
|
375 |
|
|
## For-loop where j is each injection number.
|
376 |
|
|
## Treat function as having three separate phases.
|
377 |
|
|
for j in range(inj):
|
378 |
|
|
if ((ti[j]+tp) <= time[i] <= (ti[j])):
|
379 |
|
|
## Pre-binding phase.
|
380 |
|
|
if np.isnan(y[i-1]): y[i-1]=0
|
381 |
|
|
y[i] = (0.6 * y[i-1]) + (0.4 * data[i])
|
382 |
|
|
base = y[i]
|
383 |
|
|
inmodel = True
|
384 |
|
|
if ((ti[j]) <= time[i] <= (ti[j]+ta)):
|
385 |
|
|
## Binding phase
|
386 |
|
|
yb = y[i-1] - base
|
387 |
|
|
dy = c[j]*kon*(rmax-yb) - koff*yb
|
388 |
|
|
y[i] = y[i-1] + dy*dt
|
389 |
|
|
inmodel = True
|
390 |
|
|
if (y[i] > (base+rmax)): y[i] = (base+rmax) ## Avoid overshoot.
|
391 |
|
|
if ((ti[j]+ta) <= time[i] <= (ti[j]+td)):
|
392 |
|
|
## Dissociation (conc=0)
|
393 |
|
|
yb = y[i-1]-base
|
394 |
|
|
dy = 0 - koff*yb
|
395 |
|
|
y[i] = y[i-1] + dy*dt
|
396 |
|
|
inmodel = True
|
397 |
|
|
## End "for j" loop.
|
398 |
|
|
if (inmodel==False):
|
399 |
|
|
## Not modeled, e.g. regeneration.
|
400 |
|
|
y[i] = np.NaN
|
401 |
|
|
y[i] = 0 ## NaN might break mclma()?
|
402 |
|
|
## End "for i" loop.
|
403 |
|
|
return y
|
404 |
|
|
|
405 |
|
|
def simple1to1_series_def_params():
|
406 |
|
|
""""
|
407 |
|
|
Return a dictionary of default parameters for simple1to1_series model.
|
408 |
|
|
While parameters for eight injection times are provided, only the
|
409 |
|
|
first injection time is nonzero.::
|
410 |
|
|
|
411 |
|
|
>>> from numpy import arange, zeros
|
412 |
|
|
>>> defaultparam0 = simple1to1_series_def_params()
|
413 |
|
|
>>> data0 = simple1to1_series(arange(300), zeros(300), defaultparam0)
|
414 |
|
|
>>> print round(data0[298], 1)
|
415 |
|
|
160.3
|
416 |
|
|
"""
|
417 |
|
|
dpar = {}
|
418 |
|
|
dpar['kon'] = dict(value=1e4, min=1e2, max=1e7, fixed=True)
|
419 |
|
|
dpar['koff'] = dict(value=1e-2, min=1e-6, max=1e-1, fixed=True)
|
420 |
|
|
dpar['rmax'] = dict(value=1e3, min=1e1, max=1e4, fixed=True)
|
421 |
|
|
dpar['tp'] = dict(value=-50.0, min=-50.0, max=-50.0, fixed=True)
|
422 |
|
|
dpar['ta'] = dict(value=100.0, min=100.0, max=100.0, fixed=True)
|
423 |
|
|
dpar['td'] = dict(value=100.0, min=100.0, max=100.0, fixed=True)
|
424 |
|
|
## Set all eight concentrations to 1uM.
|
425 |
|
|
for key in ['c0','c1','c2','c3','c4','c5','c6','c7']:
|
426 |
|
|
dpar[key] = dict(value=1e-6, min=1e-12, max=1e-1, fixed=True)
|
427 |
|
|
## Just describe the first injection at t0=100s.
|
428 |
|
|
for key in ['t0','t1','t2','t3','t4','t5','t6','t7']:
|
429 |
|
|
dpar[key] = dict(value=0.0, min=0.0, max=0.0, fixed=True)
|
430 |
|
|
dpar['t0'] = dict(value=100.0, min=100.0, max=100.0, fixed=True)
|
431 |
|
|
return dpar
|
432 |
clausted |
26 |
|
433 |
clausted |
60 |
|
434 |
|
|
def _test():
|
435 |
|
|
"""
|
436 |
|
|
Automatic Code testing with doctest.
|
437 |
|
|
Doctest runs the example code in the docstrings.
|
438 |
|
|
Enable use of ellipses as wildcard for returned text.
|
439 |
|
|
"""
|
440 |
|
|
import doctest
|
441 |
|
|
doctest.testmod(optionflags=doctest.ELLIPSIS)
|
442 |
|
|
|
443 |
|
|
|
444 |
|
|
if __name__ == "__main__":
|
445 |
|
|
"""
|
446 |
|
|
Code testing.
|
447 |
|
|
Simply execute 'python mdl_module.py'.
|
448 |
|
|
"""
|
449 |
|
|
_test()
|
450 |
|
|
|
451 |
clausted |
53 |
################################# End of module ###############################
|