Class "dat" for model and data storage

Share:

Description

dat is the super-class of other classes representing models and data, so that other model/data classes (e.g., kin and spec for kinetic and spectral models respectively) also have the slots defined here. Slots whose description are marked with *** may be specified in the ... argument of the initModel function.

Objects from the Class

Objects from the class can be created by calls of the form new("dat", ...) or dat(...), but most are most often made by invoking another function such as readData or initModel.

Slots

chinde
clinde
clpequspecBD
cohcol
compnames
highcon
lowcon
mvecind
nvecind
outMat
satMat
usecompnames0
usecompnamesequ
weightList
dscalspec
getX
getXsuper
weightpar:

*** Object of class "list" list of vectors c(first_x, last_x, first_x2, last_x2, weight), where each vector is of length 5 and specifies an interval in which to weight the data.

  • first\_xfirst(absolute, not an index) x to weight

  • last\_xlast (absolute, not an index) x to weight

  • first\_x2first (absolute, not an index) x2 to weight

  • last\_x2last (absolute, not an index) x2 to weight

  • weightnumeric by which to weight data

Note that if vector elements 1-4 are NA (not a number), the firstmost point of the data is taken for elements 1 and 3, and the lastmost points are taken for 2 and 4. For example, weightpar = list(c(40, 1500, 400, 600, .9), c(NA, NA, 700, 800, .1)) will weight data between times 40 and 1500 picoseconds and 700 and 800 wavelengths by .9, and will weight data at all times between wavelength 700 and 800 by .1. Note also that for single photon counting data weightpar = list(poisson = TRUE) will apply poisson weighting to all non-zero elements of the data.

mod_type:

*** Object of class "character" character string defining the model type, e.g., "kin" or "spec"

fixed:

*** Object of class "list" list of lists or vectors giving the parameter values to fix (at their starting values) during optimization.

free:

*** Object of class "list" list of lists or vectors giving the parameter values to free during optimization; if this list is present then all parameters not specified in it are fixed, e.g., free = list(irfpar = 2) will fix every parameter at its starting value except for the 2nd irfpar. If fix = list(none=TRUE) (or if the element none has length greater than 0) then all parameters in the model are fixed. Note that this option only should be applied to multiexperiment models in which at least one parameter appling to some other dataset is optimized (nls always must have at least one parameter to optimize).

constrained:

*** Object of class "list" list whose elements are lists containing a character vector what, a vector ind, and either (but not both) a character vector low and high. what should specify the parameter type to constrain. ind should give the index of the parameter to be constrained, e.g., 1 if indexing into a vector, and c(1,2) if indexing into a list. low gives a number that the parameter should always remain lower than and high gives a number that the parameter should always remain higher than (so that low bounds the parameter value from above and high bounds the parameter value from below). It is not now possible to specify both low and high for a single parameter value. An example of a complete constrained specification is constrained = list(list(what = "kinpar", ind = 2, low = .3), list(what = "parmu", ind = c(1,1), high = .002))

clp0:

*** Object of class "list" list of lists with elements low, high and comp, specifying the least value in x2 to constrain to zero, the greatest value in x2 to constrain to zero, and the component to which to apply the zero constraint, respectively. e.g., clp0 = list(list(low=400, high = 600, comp=2), list(low = 600, high = 650, comp=4)) applies zero constraints to the spectra associated with components 2 and 4.

autoclp0:

*** Object of class "list" that has two elements; oldRes, the output of fitModel and an index ind representing the index of the dataset to use in oldRes; ind defaults to one. The clp that are negative in oldRes are constrained to zero in the new model; this is primarily useful when fitting a model, finding some negative clp, and constraining them to zero by fitting again with this option. See also the help page for opt for other ways to constrain the clp to non-negativity.

clpequspec:

*** Object of class "list" list of lists each of which has elements to, from, low, high, and optional element dataset to specify the dataset from which to get the reference clp (that is, a spectrum for kinetic models). to is the component to be fixed in relation to some other component; from is the reference component. low and high are the least and greatest absolute values of the clp vector to constrain. e.g., clpequspec = list(list(low = 400, high = 600, to = 1, from = 2)) will constrain the first component to equality to the second component between wavelengths 400 and 600. Note that equality constraints are actually constraints to a linear relationship. For each of the equality constraints specfied as a list in the clpequspec list, specify a starting value parameterizing this linear relation in the vector clpequ; if true equality is desired then fix the corresponding parameter in clpequ to 1. Note that if multiple components are constrainted, the from in the sublists should be increasing order, (i.e., (list(to=2, from=1, low=100, high=10000), list(to=3, from=1, low=10000, high=100)), not list(to=3, from=1, low=10000, high=100), list(to=2, from=1, low=10000, high=100))

clpequ:

***Object of class "vector" describes the parameters governing the clp equality constraints specified in clpequspec

prelspec:

*** Object of class "list" list of lists to specify the functional relationship between parameters, each of which has elements

  • what1character string describing the parameter type to relate, e.g., "kinpar"

  • what2the parameter type on which the relation is based; usually the same as what1

  • ind1index into what1

  • ind2index into what2

  • relcharacter string, optional argument to specify functional relation type, by default linear

e.g., prelspec = list(list(what1 = "kinpar", what2 = "kinpar", ind1 = 1, ind2 = 5)) relates the 1st element of kinpar to the 5th element of kinpar. The starting values parameterizing the relationship are given in the prel vector

positivepar:

*** Object of class "vector" containing character strings of those parameter vectors to constrain to positivity, e.g., positivepar=c("kinpar")

weight:

Object of class "logical" TRUE when the specification in weightpar is to be applied and FALSE otherwise

psi.df:

Object of class "matrix" dataset from 1 experiment

psi.weight:

Object of class "matrix" weighted dataset from 1 experiment

x:

Object of class "vector" time or other independent variable.

nt:

Object of class "integer" length x

x2:

Object of class "vector" vector of points in 2nd independent dimension, such as wavelengths of wavenumbers

nl:

Object of class "integer" length x2

C2:

Object of class "matrix" concentration matrix for simulated data

E2:

Object of class "matrix" matrix of spectra for simulated data

sigma:

Object of class "numeric" noise level in simulated data

parnames:

Object of class "vector" vector of parameter names, used internally

simdata:

Object of class "logical" logical that is TRUE if the data is simulated, FALSE otherwise; will determine whether values in C2 and E2 are plotted with results

weightM:

Object of class "matrix" weights

weightsmooth:

Object of class "list" type of smoothing to apply with weighting; not currently used

makeps:

Object of class "character" specifyies the prefix of files written to postscript

lclp0:

Object of class "logical" TRUE if specification in clp0 is to be applied and FALSE otherwise

lclpequ:

Object of class "logical" TRUE if specification in clpequspec is to be applied and FALSE otherwise

title:

Object of class "character" displayed on output plots

mhist:

Object of class "list" list describing fitting history

datCall:

Object of class "list" list of calls to functions

dscalspec:

Object of class "list"

dummy:

Object of class "list" containing dummy parameters

drel:

Object of class "vector" vector of starting parameters for dataset scaling relations

scalx:

Object of class "numeric" numeric by which to scale the x axis in plotting

prel

vector of starting values for the relations described in prelspec

fvecind:

Object of class "vector" vector containing indices of fixed parameters

pvecind:

Object of class "vector" used internally to store indices of related parameters.

iter:

Object of class "numeric" describing the number of iterations that is run; this is sometimes stored after fitting, but has not effect as an argument to initModel

clpCon:

Object of class "list" used internally to enforce constraints on the clp

ncomp:

Object of class "numeric" describing the number of components in a model

clpdep:

Object of class "logical" describing whether a model is dependent on the index of x2

inten:

Object of class "matrix" for use with FLIM data; represents the number of photons per pixel measured over the course of all times $t$ represented by the dataset. See the help for the readData function for more information.

datafile:

Object of class "character" containing the name of a datafile associated with the psi.df

clpType:

Object of class "character" that is "nt" if the model has clp in the "x" dimension and "nl" otherwise (so that, e.g., if mod\_type = "kin", then clpType = "nl").

Author(s)

Katharine M. Mullen, Ivo H. M. van Stokkum, Joris J. Snellenburg, Sergey P. Laptenok

See Also

kin-class, spec-class

Examples

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# simulate data 

 C <- matrix(nrow = 51, ncol = 2)
 k <- c(.5, 1)
 t <- seq(0, 2, by = 2/50)
 C[, 1] <- exp( - k[1] * t)
 C[, 2] <- exp( - k[2] * t) 
 E <- matrix(nrow = 51, ncol = 2)
 wavenum <- seq(18000, 28000, by=200)
 location <- c(25000, 20000)
 delta <- c(5000, 7000)
 amp <- c(1, 2)
 E[, 1] <- amp[1] * exp( - log(2) * (2 * (wavenum - location[1])/delta[1])^2)
 E[, 2] <- amp[2] * exp( - log(2) * (2 * (wavenum - location[2])/delta[2])^2)
 sigma <- .001
 Psi_q  <- C %*% t(E) + sigma * rnorm(nrow(C) * nrow(E)) 

 # initialize an object of class dat 
 Psi_q_data <- dat(psi.df = Psi_q, x = t, nt = length(t), 
 x2 = wavenum, nl = length(wavenum))

 # initialize an object of class dat via initModel 
 # this dat object is also a kin object
 kinetic_model <- initModel(mod_type = "kin", seqmod = FALSE, 
 kinpar = c(.1, 2))

Want to suggest features or report bugs for rdrr.io? Use the GitHub issue tracker.