Yury V Bukhman
9 years ago
parent
67544a10e6
commit
2d658405a1
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -1,2 +1,2 @@
|
||||
^.*\.Rproj$
|
||||
^\.Rproj\.user$
|
||||
^.*\.Rproj$
|
||||
^\.Rproj\.user$
|
||||
|
||||
@ -1,159 +0,0 @@
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4_old/trunk/R/GCAT/R/addingParams.R')
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4_old/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
warnings()
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4_old/trunk/R/GCAT/R/addingParams.R')
|
||||
warnings()
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4_old/trunk/R/GCAT/R/addingParams.R')
|
||||
warnings()
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4_old/trunk/R/GCAT/R/addingParams.R')
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library("GCAT")
|
||||
library("codetools")
|
||||
checkUsagePackage("GCAT")
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
checkUsagePackage("GCAT")
|
||||
library("codetoolds")
|
||||
library("codetoolss")
|
||||
library("codetools")
|
||||
checkUsagePackage("GCAT")
|
||||
library(GCAT)
|
||||
library("codetools")
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
checkUsagePackage("GCAT")
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/fit.model.R')
|
||||
library(GCAT)
|
||||
checkUsagePackage("GCAT")
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
checkUsagePackage("GCAT")
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/class.model.R')
|
||||
library(GCAT)
|
||||
checkUsagePackage("GCAT")
|
||||
library(GCAT)
|
||||
checkUsagePackage("GCAT")
|
||||
library(GCAT)
|
||||
checkUsagePackage("GCAT")
|
||||
?? checkusagePackage
|
||||
checkUsagePackage("GCAT", all + T)
|
||||
checkUsagePackage("GCAT", all = T)
|
||||
checkUsagePackage("GCAT")
|
||||
checkUsagePackage("GCAT")
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/plot.fit.R')
|
||||
library(GCAT)
|
||||
checkUsagePackage("GCAT")
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
t
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/plot.fit.R')
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/plot.fit.R')
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/table2well.R')
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
library("codetools")
|
||||
library("GCAT")
|
||||
checkUsagePackage(GCAT)
|
||||
checkUsagePackage("GCAT)
|
||||
checkUsagePackage("GCAT")
|
||||
checkUsagePackage("GCAT")
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R')
|
||||
t
|
||||
checkUsagePack(GCAT)
|
||||
checkUsagePackage(GCAT)
|
||||
checkUsagePackage("GCAT")
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/normalize.and.transform.R')
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
source('~/Documents/GCAT4/trunk/R/GCAT/R/plot.fit.R')
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
?? plot
|
||||
? plot
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library(GCAT)
|
||||
library("codetools")
|
||||
checkPackageUsage("GCAT")
|
||||
checkUsagePackage("GCAT")
|
||||
checkUsagePackage("GCAT", all = T)
|
||||
@ -1,4 +0,0 @@
|
||||
auto_roxygenize_for_build_and_reload="1"
|
||||
auto_roxygenize_for_build_package="1"
|
||||
auto_roxygenize_for_check="1"
|
||||
makefile_args=""
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@ -1,16 +0,0 @@
|
||||
{
|
||||
"contents" : "#Copyright 2012 The Board of Regents of the University of Wisconsin System.\n#Contributors: Jason Shao, James McCurdy, Enhai Xie, Adam G.W. Halstead, \n#Michael H. Whitney, Nathan DiPiazza, Trey K. Sato and Yury V. Bukhman\n#\n#This file is part of GCAT.\n#\n#GCAT is free software: you can redistribute it and/or modify\n#it under the terms of the GNU Lesser General Public License as published by\n#the Free Software Foundation, either version 3 of the License, or\n#(at your option) any later version.\n#\n#GCAT is distributed in the hope that it will be useful,\n#but WITHOUT ANY WARRANTY; without even the implied warranty of\n#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n#GNU Lesser General Public License for more details.\n#\n#You should have received a copy of the GNU Lesser General Public License \n#along with GCAT. If not, see <http://www.gnu.org/licenses/>.\n\n# Wrapper for sapply to use lapply over an array, conserving the dimensions.\naapply = function(x, FUN,...){\n dim.values = dim(x)\n\tdim.names = dimnames(x)\n\tx = lapply(x, function(x){FUN(x,...)})\n\tdim(x) = dim.values\n\tdimnames(x) = dim.names\n\treturn(x)\n\t}\n\n# A function to manually create an unchecked exception.\nexception = function(class, msg)\n{\n cond <- simpleError(msg)\n class(cond) <- c(class, \"MyException\", class(cond))\n stop(cond)\n}\n",
|
||||
"created" : 1425413273698.000,
|
||||
"dirty" : false,
|
||||
"encoding" : "UTF-8",
|
||||
"folds" : "",
|
||||
"hash" : "3044086993",
|
||||
"id" : "4E20D973",
|
||||
"lastKnownWriteTime" : 1424208963,
|
||||
"path" : "~/Documents/GCAT4/trunk/R/GCAT/R/misc.R",
|
||||
"project_path" : "R/misc.R",
|
||||
"properties" : {
|
||||
},
|
||||
"source_on_save" : false,
|
||||
"type" : "r_source"
|
||||
}
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@ -1,16 +0,0 @@
|
||||
{
|
||||
"contents" : "# Default NAMESPACE created by R\n# Remove the previous line if you edit this file\n\n# Export all names\nexportPattern(\".\")\n\n# Import all packages listed as Imports or Depends\nimport(\"pheatmap\", \"gplots\")\n",
|
||||
"created" : 1428439772005.000,
|
||||
"dirty" : false,
|
||||
"encoding" : "UTF-8",
|
||||
"folds" : "",
|
||||
"hash" : "749067415",
|
||||
"id" : "907B51DB",
|
||||
"lastKnownWriteTime" : 1423260997,
|
||||
"path" : "~/Documents/GCAT4/trunk/R/GCAT/NAMESPACE",
|
||||
"project_path" : "NAMESPACE",
|
||||
"properties" : {
|
||||
},
|
||||
"source_on_save" : false,
|
||||
"type" : "r_namespace"
|
||||
}
|
||||
@ -1,16 +0,0 @@
|
||||
{
|
||||
"contents" : "#Copyright 2012 The Board of Regents of the University of Wisconsin System.\n#Contributors: Jason Shao, James McCurdy, Enhai Xie, Adam G.W. Halstead,\n#Michael H. Whitney, Nathan DiPiazza, Trey K. Sato and Yury V. Bukhman\n#\n#This file is part of GCAT.\n#\n#GCAT is free software: you can redistribute it and/or modify\n#it under the terms of the GNU Lesser General Public License as published by\n#the Free Software Foundation, either version 3 of the License, or\n#(at your option) any later version.\n#\n#GCAT is distributed in the hope that it will be useful,\n#but WITHOUT ANY WARRANTY; without even the implied warranty of\n#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n#GNU Lesser General Public License for more details.\n#\n#You should have received a copy of the GNU Lesser General Public License \n#along with GCAT. If not, see <http://www.gnu.org/licenses/>.\n########################################################################\n# #\n# <model> class definition and functions. Objects contain equations #\n# and other information for parameterized growth curve models. #\n# #\n########################################################################\nsetClass(\"model\", representation(name = \"character\",\n expression = \"expression\",\n formula = \"formula\",\n guess = \"function\"))\n# Slots:\n# name - a simple description of the model.\n# expression - an object of class \"expression\" that evaluates the response (transformed OD) with respect to the variable Time.\n# formula - same as expression, but with y as the response.\n# guess - a function that computes initial guesses for the parameters given a well object with a valid \"screen.data\" slot\n# containing useable OD values and slope estimates\n# --------------------------------------------------------------------\n###################### BEGIN PROTOTYPING ACCESSOR METHODS##############\n\n# Minh: Let this code fragment be F1.\nif (!isGeneric(\"getName\")){\n if (is.function(\"getName\"))\n fun <- getName\n else\n fun <- function(object) standardGeneric(\"getName\")\n setGeneric(\"getName\", fun)\n}\n# End of F1\nsetMethod(\"getName\", \"model\", function(object) object@name)\n\n# Minh: Let this line be F2.\nsetGeneric(\"getExpression\", function(object){standardGeneric(\"getExpression\")})\n# Question: How is F1 different from F2?\n\nsetMethod(\"getExpression\", \"model\",\n function(object){\n return(object@expression)\n })\n\nsetGeneric(\"getFormula\", function(object){standeardGeneric(\"getFormula\")})\nsetMethod(\"getFormula\", \"model\", \n function(object){\n return(object@formula)\n })\n\nsetGeneric(\"getGuess\", function(object){standeardGeneric(\"getGuess\")})\nsetMethod(\"getGuess\", \"model\", \n function(object){\n return(object@guess)\n })\n######################## ENG PROTOTYPING ########################\n\n# Function to create a new model\n#' Model \n#' \n#' Function to create a new model \n#' @param name The name of the model \n#' @param expression Expression of the model \n#' @param formula The formula of this model \n#' @param guess The guess of this model \n#' @return The new model \nmodel = function(name, expression, formula, guess){\n new(\"model\", name = name, expression = expression, formula = formula, guess = guess)\n}\n\nloess.g = function(well,smooth.param=0.75){\n #data = data.from(well)\n #growth = data[,2]\n #Time = data[,1]\n Time = data.from(well)[,1]\n \n # predicted growth values to be used in estimating growth curve parameters\n loess.fit = loess(data.from(well)[,2]~Time,span=smooth.param)\n t = seq(from = min(Time), to = max(Time), by = (max(Time)-min(Time))/1000)\n y = predict(loess.fit, data.frame(Time=t))\n attr(y,\"names\") = NULL # need to remove the names to prevent them from showing up in the returned vector\n \n # Remove any data points where y has not been estimated\n filt = is.finite(y)\n t = t[filt]\n y = y[filt] # remove any NA etc\n \n # specific growth using loess to find max derivative\n delta.t = diff(t)\n dydt = diff(y)/delta.t\n u = max(dydt)\n \n # lower and upper asymptotes\n b = min(y)\n A = max(y) - min(y)\n \n # inflection point\n inflection.pt.index = which.max(dydt)\n inflection.time = t[inflection.pt.index]\n inflection.y = y[inflection.pt.index]\n \n # lag time\n lam = inflection.time - (inflection.y-b)/u\n \n # Return named array of estimates\n c(A = A, b = b, lam = lam, u = u)\n}\n\n\n",
|
||||
"created" : 1425419995370.000,
|
||||
"dirty" : false,
|
||||
"encoding" : "UTF-8",
|
||||
"folds" : "",
|
||||
"hash" : "2225975310",
|
||||
"id" : "992E3490",
|
||||
"lastKnownWriteTime" : 1425511077,
|
||||
"path" : "~/Documents/GCAT4/trunk/R/GCAT/R/class.model.R",
|
||||
"project_path" : "R/class.model.R",
|
||||
"properties" : {
|
||||
},
|
||||
"source_on_save" : false,
|
||||
"type" : "r_source"
|
||||
}
|
||||
File diff suppressed because one or more lines are too long
@ -1,17 +0,0 @@
|
||||
{
|
||||
"contents" : "setwd(\"~/Downloads/\")\nfile.list = file.name = \"YPDAFEXglucoseTests_2-25-10.csv\"\nlayout.file = \"YPDAFEXglucoseTests_2-25-10_Layout.csv\"\nsingle.plate = T\nout.dir = getwd()\ngraphic.dir = paste(out.dir, \"/pics\", sep = \"\")\nadd.constant = 1\nblank.value = NULL\nstart.index = 2\ngrowth.cutoff = 0.05\nuse.linear.param = F\nuse.loess = F\nsmooth.param = 0.6\npoints.to.remove = 0\nremove.jumps = F\nsilent = F\nverbose = T\nreturn.fit = F\noverview.jpgs = T\nplate.nrow = 8\nplate.ncol = 12\ninput.skip.lines = 0\nmulti.column.headers = c(\"Plate ID\", \"Well\", \"OD\", \"Time\")\nsingle.column.headers = c(\"\",\"A1\")\nlayout.sheet.headers = c(\"Strain\", \"Media Definition\")\n\nt = gcat.analysis.main(file.list, single.plate, layout.file = NULL, \n out.dir = getwd(), graphic.dir = paste(out.dir, \"/pics\", sep = \"\"), \n add.constant = 1, blank.value = NULL, start.index = 2, growth.cutoff = 0.05,\n use.linear.param=use.linear.param, use.loess=use.loess, smooth.param=0.1,\n points.to.remove = 0, remove.jumps = F, time.input = NA,\n plate.nrow = 8, plate.ncol = 12, input.skip.lines = 0,\n multi.column.headers = c(\"Plate.ID\", \"Well\", \"OD\", \"Time\"), single.column.headers = c(\"\",\"A1\"), \n layout.sheet.headers = c(\"Strain\", \"Media Definition\"),\n silent = F, verbose = F, return.fit = F, overview.jpgs = T)\n",
|
||||
"created" : 1425413468083.000,
|
||||
"dirty" : false,
|
||||
"encoding" : "UTF-8",
|
||||
"folds" : "",
|
||||
"hash" : "3533220190",
|
||||
"id" : "E3886516",
|
||||
"lastKnownWriteTime" : 1425422563,
|
||||
"path" : "~/Documents/GCAT4/trunk/R/GCAT/R/addingParams.R",
|
||||
"project_path" : "R/addingParams.R",
|
||||
"properties" : {
|
||||
"tempName" : "Untitled1"
|
||||
},
|
||||
"source_on_save" : false,
|
||||
"type" : "r_source"
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,3 +0,0 @@
|
||||
{
|
||||
"tempName" : "Untitled1"
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,3 +0,0 @@
|
||||
{
|
||||
"tempName" : "Untitled1"
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,18 +0,0 @@
|
||||
~%2FDocuments%2FGCAT4%2Ftrunk%2FR%2FGCAT%2FNAMESPACE="972C75E0"
|
||||
~%2FDocuments%2FGCAT4%2Ftrunk%2FR%2FGCAT%2FR%2FGCAT.main.R="11120BC5"
|
||||
~%2FDocuments%2FGCAT4%2Ftrunk%2FR%2FGCAT%2FR%2FaddingParams.R="54A894D0"
|
||||
~%2FDocuments%2FGCAT4%2Ftrunk%2FR%2FGCAT%2FR%2Fclass.model.R="9127986F"
|
||||
~%2FDocuments%2FGCAT4%2Ftrunk%2FR%2FGCAT%2FR%2Fclass.well.R="8250000E"
|
||||
~%2FDocuments%2FGCAT4%2Ftrunk%2FR%2FGCAT%2FR%2Ffit.model.R="3F8DCF42"
|
||||
~%2FDocuments%2FGCAT4%2Ftrunk%2FR%2FGCAT%2FR%2Ffitted.calculations.R="E533697B"
|
||||
~%2FDocuments%2FGCAT4%2Ftrunk%2FR%2FGCAT%2FR%2Fmisc.R="8341E8EB"
|
||||
~%2FDocuments%2FGCAT4%2Ftrunk%2FR%2FGCAT%2FR%2Fnormalize.and.transform.R="EDBD9DE"
|
||||
~%2FDocuments%2FGCAT4%2Ftrunk%2FR%2FGCAT%2FR%2Fplot.fit.R="2E01469A"
|
||||
~%2FDocuments%2FGCAT4%2Ftrunk%2FR%2FGCAT%2FR%2Fslope.analysis.R="4E0B0FCA"
|
||||
~%2FDocuments%2FGCAT4%2Ftrunk%2FR%2FGCAT%2FR%2Ftable.output.R="B005EA5F"
|
||||
~%2FDocuments%2FGCAT4%2Ftrunk%2FR%2FGCAT%2FR%2Ftable2well.R="A3297EED"
|
||||
~%2FDocuments%2FGCAT4%2Ftrunk%2FR%2FGCAT%2Fman%2Fgcat.load.data.Rd="2A2D32C6"
|
||||
~%2FDocuments%2FGCAT4_old%2Ftrunk%2FR%2FGCAT%2FR%2FGCAT.main.R="61AC4784"
|
||||
~%2FDocuments%2FGCAT4_old%2Ftrunk%2FR%2FGCAT%2FR%2FaddingParams.R="DEDB5126"
|
||||
~%2FDocuments%2FGCAT4_old%2Ftrunk%2FR%2FGCAT%2FR%2Fclass.model.R="8CEE19EC"
|
||||
~%2FDocuments%2FGCAT4_old%2Ftrunk%2FR%2FGCAT%2FR%2Ffit.model.R="9D1E246E"
|
||||
@ -1,8 +1,24 @@
|
||||
# Default NAMESPACE created by R
|
||||
# Remove the previous line if you edit this file
|
||||
# Generated by roxygen2 (4.1.1): do not edit by hand
|
||||
|
||||
# Export all names
|
||||
exportPattern(".")
|
||||
|
||||
# Import all packages listed as Imports or Depends
|
||||
import("pheatmap", "gplots")
|
||||
export(gcat.analysis.main)
|
||||
exportClasses(well)
|
||||
exportMethods(getAddInfo)
|
||||
exportMethods(getCurPar)
|
||||
exportMethods(getEquation)
|
||||
exportMethods(getFitErr)
|
||||
exportMethods(getFitInfo)
|
||||
exportMethods(getFitPar)
|
||||
exportMethods(getInflectionTime)
|
||||
exportMethods(getLoess)
|
||||
exportMethods(getModelName)
|
||||
exportMethods(getNorm)
|
||||
exportMethods(getPosition)
|
||||
exportMethods(getRSS)
|
||||
exportMethods(getScreenData)
|
||||
exportMethods(getStartIndex)
|
||||
exportMethods(getUseLog)
|
||||
exportMethods(getWellInfo)
|
||||
exportMethods(getnls)
|
||||
import(gplots)
|
||||
import(methods)
|
||||
import(pheatmap)
|
||||
|
||||
@ -1,17 +0,0 @@
|
||||
Version: 1.0
|
||||
|
||||
RestoreWorkspace: Default
|
||||
SaveWorkspace: Default
|
||||
AlwaysSaveHistory: Default
|
||||
|
||||
EnableCodeIndexing: Yes
|
||||
UseSpacesForTab: Yes
|
||||
NumSpacesForTab: 2
|
||||
Encoding: UTF-8
|
||||
|
||||
RnwWeave: Sweave
|
||||
LaTeX: pdfLaTeX
|
||||
|
||||
BuildType: Package
|
||||
PackageInstallArgs: --no-multiarch --with-keep.source
|
||||
PackageRoxygenize: rd
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@ -1,16 +0,0 @@
|
||||
{
|
||||
"contents" : "#Copyright 2012 The Board of Regents of the University of Wisconsin System.\n#Contributors: Jason Shao, James McCurdy, Enhai Xie, Adam G.W. Halstead,\n#Michael H. Whitney, Nathan DiPiazza, Trey K. Sato and Yury V. Bukhman\n#\n#This file is part of GCAT.\n#\n#GCAT is free software: you can redistribute it and/or modify\n#it under the terms of the GNU Lesser General Public License as published by\n#the Free Software Foundation, either version 3 of the License, or\n#(at your option) any later version.\n#\n#GCAT is distributed in the hope that it will be useful,\n#but WITHOUT ANY WARRANTY; without even the implied warranty of\n#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n#GNU Lesser General Public License for more details.\n#\n#You should have received a copy of the GNU Lesser General Public License \n#along with GCAT. If not, see <http://www.gnu.org/licenses/>.\n########################################################################\n# #\n# <model> class definition and functions. Objects contain equations #\n# and other information for parameterized growth curve models. #\n# #\n########################################################################\nsetClass(\"model\", representation(name = \"character\",\n expression = \"expression\",\n formula = \"formula\",\n guess = \"function\"))\n# Slots:\n# name - a simple description of the model.\n# expression - an object of class \"expression\" that evaluates the response (transformed OD) with respect to the variable Time.\n# formula - same as expression, but with y as the response.\n# guess - a function that computes initial guesses for the parameters given a well object with a valid \"screen.data\" slot\n# containing useable OD values and slope estimates\n# --------------------------------------------------------------------\n# Function to create a new model \t \n#' Model \n#' \n#' Function to create a new model \n#' @param name The name of the model \n#' @param expression Expression of the model \n#' @param formula The formula of this model \n#' @param guess The guess of this model \n#' @return The new model \nmodel = function(name, expression, formula, guess){\n new(\"model\", name = name, expression = expression, formula = formula, guess = guess)\n}\n\nloess.g = function(well,smooth.param=0.75){\n data = data.from(well)\n growth = data[,2]\n Time = data[,1]\n \n # predicted growth values to be used in estimating growth curve parameters\n loess.fit = loess(growth~Time,span=smooth.param)\n t = seq(from = min(Time), to = max(Time), by = (max(Time)-min(Time))/1000)\n y = predict(loess.fit, data.frame(Time=t))\n attr(y,\"names\") = NULL # need to remove the names to prevent them from showing up in the returned vector\n \n # Remove any data points where y has not been estimated\n filt = is.finite(y)\n t = t[filt]\n y = y[filt] # remove any NA etc\n \n # specific growth using loess to find max derivative\n delta.t = diff(t)\n dydt = diff(y)/delta.t\n u = max(dydt)\n \n # lower and upper asymptotes\n b = min(y)\n A = max(y) - min(y)\n \n # inflection point\n inflection.pt.index = which.max(dydt)\n inflection.time = t[inflection.pt.index]\n inflection.y = y[inflection.pt.index]\n \n # lag time\n lam = inflection.time - (inflection.y-b)/u\n \n # Return named array of estimates\n c(A = A, b = b, lam = lam, u = u)\n}\n\n\n",
|
||||
"created" : 1423869204555.000,
|
||||
"dirty" : false,
|
||||
"encoding" : "UTF-8",
|
||||
"folds" : "",
|
||||
"hash" : "3423035371",
|
||||
"id" : "EE21755B",
|
||||
"lastKnownWriteTime" : 1423869219,
|
||||
"path" : "~/Documents/GCAT4_old/trunk/R/GCAT/R/class.model.R",
|
||||
"project_path" : "class.model.R",
|
||||
"properties" : {
|
||||
},
|
||||
"source_on_save" : false,
|
||||
"type" : "r_source"
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
{
|
||||
}
|
||||
@ -1,7 +0,0 @@
|
||||
~%2FDocuments%2FGCAT4_old%2Ftrunk%2FR%2FGCAT%2FR%2FGCAT.main.R="59ABD774"
|
||||
~%2FDocuments%2FGCAT4_old%2Ftrunk%2FR%2FGCAT%2FR%2Fclass.model.R="6E6918EE"
|
||||
~%2FDocuments%2FGCAT4_old%2Ftrunk%2FR%2FGCAT%2FR%2Ffit.model.R="5C623936"
|
||||
~%2FDocuments%2FGCAT4_old%2Ftrunk%2FR%2FGCAT%2FR%2Ffitted.calculations.R="2ACDF6EF"
|
||||
~%2FDocuments%2FGCAT4_old%2Ftrunk%2FR%2FGCAT%2FR%2Fnormalize.and.transform.R="F3CF638E"
|
||||
~%2FDocuments%2FGCAT4_old%2Ftrunk%2FR%2FGCAT%2FR%2Fplot.fit.R="EFF3E540"
|
||||
~%2FDocuments%2FGCAT4_old%2Ftrunk%2FR%2FGCAT%2FR%2Ftable2well.R="9402820B"
|
||||
@ -1,35 +0,0 @@
|
||||
setwd("~/Downloads/")
|
||||
file.list = file.name = "YPDAFEXglucoseTests_2-25-10.csv"
|
||||
layout.file = "YPDAFEXglucoseTests_2-25-10_Layout.csv"
|
||||
single.plate = T
|
||||
out.dir = getwd()
|
||||
graphic.dir = paste(out.dir, "/pics", sep = "")
|
||||
add.constant = 1
|
||||
blank.value = NULL
|
||||
start.index = 2
|
||||
growth.cutoff = 0.05
|
||||
use.linear.param = F
|
||||
use.loess = F
|
||||
smooth.param = 0.6
|
||||
points.to.remove = 0
|
||||
remove.jumps = F
|
||||
silent = F
|
||||
verbose = T
|
||||
return.fit = F
|
||||
overview.jpgs = T
|
||||
plate.nrow = 8
|
||||
plate.ncol = 12
|
||||
input.skip.lines = 0
|
||||
multi.column.headers = c("Plate ID", "Well", "OD", "Time")
|
||||
single.column.headers = c("","A1")
|
||||
layout.sheet.headers = c("Strain", "Media Definition")
|
||||
|
||||
t = gcat.analysis.main(file.list, single.plate, layout.file = NULL,
|
||||
out.dir = getwd(), graphic.dir = paste(out.dir, "/pics", sep = ""),
|
||||
add.constant = 1, blank.value = NULL, start.index = 2, growth.cutoff = 0.05,
|
||||
use.linear.param=use.linear.param, use.loess=use.loess, smooth.param=0.1,
|
||||
points.to.remove = 0, remove.jumps = F, time.input = NA,
|
||||
plate.nrow = 8, plate.ncol = 12, input.skip.lines = 0,
|
||||
multi.column.headers = c("Plate.ID", "Well", "OD", "Time"), single.column.headers = c("","A1"),
|
||||
layout.sheet.headers = c("Strain", "Media Definition"),
|
||||
silent = F, verbose = F, return.fit = F, overview.jpgs = T)
|
||||
@ -1,381 +1,342 @@
|
||||
#Copyright 2012 The Board of Regents of the University of Wisconsin System.
|
||||
#Contributors: Jason Shao, James McCurdy, Enhai Xie, Adam G.W. Halstead,
|
||||
#Michael H. Whitney, Nathan DiPiazza, Trey K. Sato and Yury V. Bukhman
|
||||
#
|
||||
#This file is part of GCAT.
|
||||
#
|
||||
#GCAT is free software: you can redistribute it and/or modify
|
||||
#it under the terms of the GNU Lesser General Public License as published by
|
||||
#the Free Software Foundation, either version 3 of the License, or
|
||||
#(at your option) any later version.
|
||||
#
|
||||
#GCAT is distributed in the hope that it will be useful,
|
||||
#but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
#GNU Lesser General Public License for more details.
|
||||
#
|
||||
#You should have received a copy of the GNU Lesser General Public License
|
||||
#along with GCAT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
########################################################################
|
||||
# #
|
||||
# Functions to calculate various things about wells based on fit model #
|
||||
# #
|
||||
########################################################################
|
||||
|
||||
# S3 generic
|
||||
lag <- function(fitted.well, ...)
|
||||
{
|
||||
UseMethod("lag")
|
||||
}
|
||||
|
||||
#
|
||||
# Common arguments:
|
||||
# fitted.well - should be a well containing the results of <fit.model>, most functions will return NA if well has not been fit yet.
|
||||
# unlog - should the value be returned on the linear scale as opposed to the log-transformed scale?
|
||||
# constant.added - for returning values on the linear scale, what was the constant added before the log transform?
|
||||
# digits - passed to the <round> function, default is no rounding (infinity digits)
|
||||
|
||||
unlog = function(x, constant.added) {
|
||||
########################################################################
|
||||
# Transform values back to OD scale #
|
||||
########################################################################
|
||||
exp(x) - constant.added
|
||||
}
|
||||
|
||||
well.eval = function(fitted.well, Time = NULL){
|
||||
########################################################################
|
||||
# Evaluate estimated OD at any timepoints using the fitted model #
|
||||
########################################################################
|
||||
|
||||
# If no timepoints are provided, use the ones collected in the experiment itself.
|
||||
if(!is.numeric(Time))
|
||||
Time = data.from(fitted.well)$Time
|
||||
|
||||
# Use of equation is deprecated. Use nls and loess models stored in the well object instead
|
||||
# Attempt to use <eval> with the fitted equation and parameters to get estimates for OD at the given timepoints.
|
||||
#output = try(eval(fitted.well@equation, fitted.well@fit.par), silent = T)
|
||||
|
||||
# Predict log.OD value(s) using nls model if present. If no nls model, try using loess.
|
||||
if (length(fitted.well@nls)>0) {
|
||||
output = try(predict(fitted.well@nls,list(Time=Time)),silent=T)
|
||||
} else if (length(fitted.well@loess)>0) {
|
||||
output = try(predict(fitted.well@loess,Time),silent=T)
|
||||
} else {
|
||||
output = NA
|
||||
}
|
||||
|
||||
# Return values. If OD evaluation failed for any reason, return NULL.
|
||||
if (is.numeric(output)){
|
||||
return(output)
|
||||
} else {
|
||||
return(NULL)
|
||||
}
|
||||
}
|
||||
|
||||
model.residuals = function(fitted.well, unlog = F){
|
||||
########################################################################
|
||||
# Evaluate model residuals using the measured vs. fitted log.OD values #
|
||||
########################################################################
|
||||
measured.OD = data.from(fitted.well)[,2]
|
||||
|
||||
# Use <well.eval> with no Time argument to get fitted OD values at measured timepoints.
|
||||
predicted.OD = well.eval(fitted.well)
|
||||
|
||||
# If all values are valid, return the differences
|
||||
if (!is.numeric(predicted.OD))
|
||||
return(NA)
|
||||
else
|
||||
return(measured.OD - predicted.OD)
|
||||
}
|
||||
|
||||
dev.from.mean = function(fitted.well){
|
||||
########################################################################
|
||||
# Evaluate deviations of log.OD values from the mean #
|
||||
########################################################################
|
||||
measured.ODs = data.from(fitted.well,remove=T,na.rm=T)[,2]
|
||||
|
||||
# Get the mean values of these measured ODs.
|
||||
mean.ODs = mean(measured.ODs)
|
||||
|
||||
if (!is.numeric(mean.ODs))
|
||||
return (NA)
|
||||
else
|
||||
return (measured.ODs - mean.ODs)
|
||||
}
|
||||
|
||||
rss = function(fitted.well){
|
||||
#######################################################################
|
||||
# Get the residual sum of square. #
|
||||
#######################################################################
|
||||
if (length(fitted.well@rss) == 0)
|
||||
return (NA)
|
||||
else
|
||||
return (fitted.well@rss)
|
||||
}
|
||||
|
||||
model.good.fit = function(fitted.well, digits = Inf){
|
||||
########################################################################
|
||||
# Calculate a metric for fit accuracy using squared residuals #
|
||||
########################################################################
|
||||
|
||||
# Sum of squared residuals
|
||||
RSS = rss(fitted.well)
|
||||
|
||||
# Total sum of squared
|
||||
tot = sum(dev.from.mean(fitted.well)^2)
|
||||
|
||||
# Coefficient of determination
|
||||
return (1 - RSS/tot)
|
||||
}
|
||||
|
||||
parameter.text = function(fitted.well){
|
||||
########################################################################
|
||||
# Output a string with values of fitted parameters #
|
||||
########################################################################
|
||||
|
||||
# Get a list of fitted parameters
|
||||
fit.par = fitted.well@fit.par
|
||||
|
||||
# Giving the parameter text descriptive names.
|
||||
if (length(fitted.well@fit.par) != 0){
|
||||
names(fit.par)[1] = "A"
|
||||
names(fit.par)[2] = "b"
|
||||
names(fit.par)[3] = "lambda"
|
||||
names(fit.par)[4] = "max.spec.growth.rate"
|
||||
|
||||
if (fitted.well@model.name == "richards sigmoid"){
|
||||
names(fit.par)[5] = "shape.par"
|
||||
}
|
||||
|
||||
if (fitted.well@model.name == "richards sigmoid with linear par."){
|
||||
names(fit.par)[5] = "shape.param"
|
||||
names(fit.par)[6] = "linear term"
|
||||
}
|
||||
|
||||
if (fitted.well@model.name == "logistic sigmoid with linear par.")
|
||||
names(fit.par)[5] = "linear.term"
|
||||
|
||||
# if loess, just show smoothing param
|
||||
if(fitted.well@model.name == "local polynomial regression fit.")
|
||||
fit.par = fitted.well@fit.par["smoothing parameter"]
|
||||
}
|
||||
|
||||
# Return nothing if the list is empty. Otherwise, concatenate the terms in the list with the parameter names.
|
||||
if(!is.list(fit.par))
|
||||
return()
|
||||
else{
|
||||
output = ""
|
||||
i = 1
|
||||
while(i <= length(fit.par)){
|
||||
output = paste(output, names(fit.par)[i], "=", round(as.numeric(fit.par[i]),3), "; ", sep = "")
|
||||
i = i + 1
|
||||
if (i %% 6 == 0)
|
||||
output = paste(output, "\n")
|
||||
}
|
||||
output
|
||||
}
|
||||
}
|
||||
|
||||
max.spec.growth.rate = function(fitted.well, digits = Inf, ...){
|
||||
########################################################################
|
||||
# Calculate maximum specific growth rate #
|
||||
########################################################################
|
||||
if(length(fitted.well@fit.par) == 0)
|
||||
return(NA)
|
||||
|
||||
round(fitted.well@fit.par$u,digits)
|
||||
}
|
||||
|
||||
|
||||
plateau = function(fitted.well, digits = Inf){
|
||||
########################################################################
|
||||
# Calculate plateau log.OD from fitted parameters #
|
||||
########################################################################
|
||||
if(length(fitted.well@fit.par) == 0)
|
||||
return(NA)
|
||||
|
||||
plat = fitted.well@fit.par$A + fitted.well@fit.par$b
|
||||
|
||||
if (!is.numeric(plat)) {
|
||||
plat = NA
|
||||
} else {
|
||||
plat = round(plat, digits)
|
||||
}
|
||||
return(plat)
|
||||
}
|
||||
|
||||
baseline = function(fitted.well, digits = Inf){
|
||||
########################################################################
|
||||
# Calculate baseline log.OD from fitted parameters #
|
||||
########################################################################
|
||||
if(length(fitted.well@fit.par) == 0)
|
||||
return(NA)
|
||||
|
||||
base = fitted.well@fit.par$b
|
||||
|
||||
# If A (plateau OD) is invalid, return NA.
|
||||
if (!is.numeric(fitted.well@fit.par$A))
|
||||
base = NA
|
||||
# If b (baseline OD) is invalid but plateau OD was valid, return zero.
|
||||
else if (!is.numeric(base))
|
||||
base = 0
|
||||
else{
|
||||
base = round(base, digits)
|
||||
}
|
||||
return(base)
|
||||
}
|
||||
|
||||
inoc.log.OD = function(fitted.well, digits = Inf){
|
||||
########################################################################
|
||||
# Calculate log.OD at inoculation from fitted parameters #
|
||||
########################################################################
|
||||
|
||||
# Evaluated the fitted model at the inoculation timepoint (should be zero from using <start.times> from table2wells.R)
|
||||
if (is.null(well.eval(fitted.well)))
|
||||
return(NA)
|
||||
else{
|
||||
inoc.time = fitted.well@screen.data$Time[fitted.well@start.index]
|
||||
inoc.log.OD = well.eval(fitted.well, inoc.time)
|
||||
if (is.na(inoc.log.OD)) inoc.log.OD = fitted.well@fit.par$b # need this in a special case: loess fits with start.index = 1
|
||||
return(round(inoc.log.OD, digits))
|
||||
}
|
||||
}
|
||||
|
||||
max.log.OD = function(fitted.well, digits = Inf, ...){
|
||||
########################################################################
|
||||
# Calculate max log.OD from model fit #
|
||||
########################################################################
|
||||
|
||||
# Evaluated the fitted model at the final timepoint (just the last valid timepoint in the experiment)
|
||||
if (is.null(well.eval(fitted.well)))
|
||||
return(NA)
|
||||
else{
|
||||
return(round(max(well.eval(fitted.well),na.rm=T), digits))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
projected.growth = function(fitted.well,digits=Inf) {
|
||||
########################################################################
|
||||
# Calculate projected growth: plateau minus the inoculated log.OD #
|
||||
########################################################################
|
||||
plateau(fitted.well,digits) - inoc.log.OD(fitted.well,digits)
|
||||
}
|
||||
|
||||
projected.growth.OD = function(fitted.well,constant.added,digits=Inf) {
|
||||
########################################################################
|
||||
# Calculate projected growth: plateau minus the inoculated log.OD #
|
||||
########################################################################
|
||||
value = unlog(plateau(fitted.well),constant.added) - unlog(inoc.log.OD(fitted.well),constant.added)
|
||||
round(value,digits)
|
||||
}
|
||||
|
||||
|
||||
achieved.growth = function(fitted.well,digits=Inf) {
|
||||
########################################################################
|
||||
# Calculate achieved growth: max.log.OD minus the inoculated log.OD #
|
||||
########################################################################
|
||||
max.log.OD(fitted.well,digits) - inoc.log.OD(fitted.well,digits)
|
||||
}
|
||||
|
||||
achieved.growth.OD = function(fitted.well,constant.added,digits=Inf) {
|
||||
########################################################################
|
||||
# Calculate projected growth: plateau minus the inoculated log.OD #
|
||||
########################################################################
|
||||
value = unlog(max.log.OD(fitted.well),constant.added) - unlog(inoc.log.OD(fitted.well),constant.added)
|
||||
round(value,digits)
|
||||
}
|
||||
|
||||
reach.plateau = function(fitted.well, cutoff = 0.75){
|
||||
########################################################################
|
||||
# Did the curve come close to the plateau OD during the experiment? #
|
||||
########################################################################
|
||||
|
||||
plat = plateau(fitted.well)
|
||||
inoc = inoc.log.OD(fitted.well)
|
||||
final = max.log.OD(fitted.well)
|
||||
|
||||
if (!is.na(final)){
|
||||
# If the plateau is the same as the OD at inoculation, return TRUE
|
||||
if ((plat - inoc) == 0)
|
||||
return(T)
|
||||
# If the difference between the final OD and inoculation OD is at least a certain proportion
|
||||
# <cutoff> of the difference between the plateau and inoculated ODs, return TRUE.
|
||||
else
|
||||
return((final - inoc) / (plat - inoc) > cutoff)
|
||||
}
|
||||
else
|
||||
return(T)
|
||||
# If no final OD was calculated (if curve was not fit properly) just return T.
|
||||
}
|
||||
|
||||
|
||||
lag.time = function(fitted.well, digits = Inf, ...){
|
||||
########################################################################
|
||||
# Calculate the lag time from the fitted OD #
|
||||
########################################################################
|
||||
if(length(fitted.well@fit.par) == 0)
|
||||
return(NA)
|
||||
|
||||
fitted.well@fit.par$lam
|
||||
}
|
||||
|
||||
# new params for GCAT 4.0
|
||||
|
||||
amplitude = function(fitted.well){
|
||||
if(length(fitted.well@fit.par) == 0)
|
||||
return(NA)
|
||||
|
||||
return(fitted.well@fit.par$A)
|
||||
}
|
||||
|
||||
shape.par = function(fitted.well){
|
||||
if(length(fitted.well@fit.par) == 0)
|
||||
return(NA)
|
||||
ifelse(is.null(fitted.well@fit.par$v), NA, fitted.well@fit.par$v)
|
||||
}
|
||||
|
||||
max.spec.growth.rate.SE = function(fitted.well, ...){
|
||||
if(length(fitted.well@fit.std.err) == 0)
|
||||
return(NA)
|
||||
ifelse(is.null(fitted.well@fit.std.err$u), NA, fitted.well@fit.std.err$u)
|
||||
}
|
||||
|
||||
lag.time.SE = function(fitted.well, ...){
|
||||
if(length(fitted.well@fit.std.err) == 0)
|
||||
return(NA)
|
||||
ifelse(is.null(fitted.well@fit.std.err$lam), NA, fitted.well@fit.std.err$lam)
|
||||
}
|
||||
|
||||
shape.par.SE = function(fitted.well){
|
||||
if(length(fitted.well@fit.std.err) == 0)
|
||||
return(NA)
|
||||
ifelse(is.null(fitted.well@fit.std.err$v), NA, fitted.well@fit.std.err$v)
|
||||
}
|
||||
|
||||
amplitude.SE = function(fitted.well){
|
||||
if(length(fitted.well@fit.std.err) == 0)
|
||||
return(NA)
|
||||
ifelse(is.null(fitted.well@fit.std.err$A), NA, fitted.well@fit.std.err$A)
|
||||
}
|
||||
|
||||
baseline.SE = function(fitted.well){
|
||||
if(length(fitted.well@fit.std.err) == 0)
|
||||
return(NA)
|
||||
ifelse(is.null(fitted.well@fit.std.err$b), NA, fitted.well@fit.std.err$b)
|
||||
}
|
||||
|
||||
# used to calulate the inflection.time value
|
||||
inflection.time = function(well){
|
||||
if (length(well@loess) == 0 && length(well@nls) == 0) return(NA) # can' compute inflection time in the absence of a fit
|
||||
data = data.from(well)
|
||||
Time = data[,1]
|
||||
t = seq(from = min(Time), to = max(Time), by = (max(Time)-min(Time))/1000)
|
||||
y = well.eval(well,t)
|
||||
if (is.null(y)) return(NA)
|
||||
delta.t = diff(t)
|
||||
dydt = diff(y)/delta.t
|
||||
infl.index = which.max(dydt)
|
||||
t[infl.index]
|
||||
}
|
||||
#Copyright 2012 The Board of Regents of the University of Wisconsin System.
|
||||
#Contributors: Jason Shao, James McCurdy, Enhai Xie, Adam G.W. Halstead,
|
||||
#Michael H. Whitney, Nathan DiPiazza, Trey K. Sato and Yury V. Bukhman
|
||||
#
|
||||
#This file is part of GCAT.
|
||||
#
|
||||
#GCAT is free software: you can redistribute it and/or modify
|
||||
#it under the terms of the GNU Lesser General Public License as published by
|
||||
#the Free Software Foundation, either version 3 of the License, or
|
||||
#(at your option) any later version.
|
||||
#
|
||||
#GCAT is distributed in the hope that it will be useful,
|
||||
#but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
#GNU Lesser General Public License for more details.
|
||||
#
|
||||
#You should have received a copy of the GNU Lesser General Public License
|
||||
#along with GCAT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
########################################################################
|
||||
# #
|
||||
# Functions to calculate various things about wells based on fit model #
|
||||
# #
|
||||
########################################################################
|
||||
|
||||
# S3 generic for lag
|
||||
lag <- function(fitted.well, ...)
|
||||
{
|
||||
UseMethod("lag")
|
||||
}
|
||||
|
||||
#
|
||||
# Common arguments:
|
||||
# fitted.well - should be a well containing the results of <fit.model>, most functions will return NA if well has not been fit yet.
|
||||
# unlog - should the value be returned on the linear scale as opposed to the log-transformed scale?
|
||||
# constant.added - for returning values on the linear scale, what was the constant added before the log transform?
|
||||
# digits - passed to the <round> function, default is no rounding (infinity digits)
|
||||
|
||||
# Transform values back to OD scale
|
||||
unlog = function(x, constant.added) {
|
||||
exp(x) - constant.added
|
||||
}
|
||||
|
||||
# Evaluate estimated OD at any timepoints using the fitted model
|
||||
well.eval = function(fitted.well, Time = NULL){
|
||||
# If no timepoints are provided, use the ones collected in the experiment itself.
|
||||
if(!is.numeric(Time))
|
||||
Time = data.from(fitted.well)$Time
|
||||
|
||||
# Use of equation is deprecated. Use nls and loess models stored in the well object instead
|
||||
# Attempt to use <eval> with the fitted equation and parameters to get estimates for OD at the given timepoints.
|
||||
#output = try(eval(fitted.well@equation, fitted.well@fit.par), silent = T)
|
||||
|
||||
# Predict log.OD value(s) using nls model if present. If no nls model, try using loess.
|
||||
if (length(fitted.well@nls)>0) {
|
||||
output = try(predict(fitted.well@nls,list(Time=Time)),silent=T)
|
||||
} else if (length(fitted.well@loess)>0) {
|
||||
output = try(predict(fitted.well@loess,Time),silent=T)
|
||||
} else {
|
||||
output = NA
|
||||
}
|
||||
|
||||
# Return values. If OD evaluation failed for any reason, return NULL.
|
||||
if (is.numeric(output)){
|
||||
return(output)
|
||||
} else {
|
||||
return(NULL)
|
||||
}
|
||||
}
|
||||
|
||||
# Evaluate model residuals using the measured vs. fitted log.OD values
|
||||
model.residuals = function(fitted.well, unlog = F){
|
||||
measured.OD = data.from(fitted.well)[,2]
|
||||
|
||||
# Use <well.eval> with no Time argument to get fitted OD values at measured timepoints.
|
||||
predicted.OD = well.eval(fitted.well)
|
||||
|
||||
# If all values are valid, return the differences
|
||||
if (!is.numeric(predicted.OD))
|
||||
return(NA)
|
||||
else
|
||||
return(measured.OD - predicted.OD)
|
||||
}
|
||||
|
||||
# Evaluate deviations of log.OD values from the mean
|
||||
dev.from.mean = function(fitted.well){
|
||||
measured.ODs = data.from(fitted.well,remove=T,na.rm=T)[,2]
|
||||
|
||||
# Get the mean values of these measured ODs.
|
||||
mean.ODs = mean(measured.ODs)
|
||||
|
||||
if (!is.numeric(mean.ODs))
|
||||
return (NA)
|
||||
else
|
||||
return (measured.ODs - mean.ODs)
|
||||
}
|
||||
|
||||
# Get the residual sum of square.
|
||||
rss = function(fitted.well){
|
||||
if (length(fitted.well@rss) == 0)
|
||||
return (NA)
|
||||
else
|
||||
return (fitted.well@rss)
|
||||
}
|
||||
|
||||
# Calculate a metric for fit accuracy using squared residuals
|
||||
model.good.fit = function(fitted.well, digits = Inf){
|
||||
# Sum of squared residuals
|
||||
RSS = rss(fitted.well)
|
||||
|
||||
# Total sum of squared
|
||||
tot = sum(dev.from.mean(fitted.well)^2)
|
||||
|
||||
# Coefficient of determination
|
||||
return (1 - RSS/tot)
|
||||
}
|
||||
|
||||
# Output a string with values of fitted parameters
|
||||
parameter.text = function(fitted.well){
|
||||
# Get a list of fitted parameters
|
||||
fit.par = fitted.well@fit.par
|
||||
|
||||
# Giving the parameter text descriptive names.
|
||||
if (length(fitted.well@fit.par) != 0){
|
||||
names(fit.par)[1] = "A"
|
||||
names(fit.par)[2] = "b"
|
||||
names(fit.par)[3] = "lambda"
|
||||
names(fit.par)[4] = "max.spec.growth.rate"
|
||||
|
||||
if (fitted.well@model.name == "richards sigmoid"){
|
||||
names(fit.par)[5] = "shape.par"
|
||||
}
|
||||
|
||||
if (fitted.well@model.name == "richards sigmoid with linear par."){
|
||||
names(fit.par)[5] = "shape.param"
|
||||
names(fit.par)[6] = "linear term"
|
||||
}
|
||||
|
||||
if (fitted.well@model.name == "logistic sigmoid with linear par.")
|
||||
names(fit.par)[5] = "linear.term"
|
||||
|
||||
# if loess, just show smoothing param
|
||||
if(fitted.well@model.name == "local polynomial regression fit.")
|
||||
fit.par = fitted.well@fit.par["smoothing parameter"]
|
||||
}
|
||||
|
||||
# Return nothing if the list is empty. Otherwise, concatenate the terms in the list with the parameter names.
|
||||
if(!is.list(fit.par))
|
||||
return()
|
||||
else{
|
||||
output = ""
|
||||
i = 1
|
||||
while(i <= length(fit.par)){
|
||||
output = paste(output, names(fit.par)[i], "=", round(as.numeric(fit.par[i]),3), "; ", sep = "")
|
||||
i = i + 1
|
||||
if (i %% 6 == 0)
|
||||
output = paste(output, "\n")
|
||||
}
|
||||
output
|
||||
}
|
||||
}
|
||||
|
||||
# Calculate maximum specific growth rate
|
||||
max.spec.growth.rate = function(fitted.well, digits = Inf, ...){
|
||||
if(length(fitted.well@fit.par) == 0)
|
||||
return(NA)
|
||||
|
||||
round(fitted.well@fit.par$u,digits)
|
||||
}
|
||||
|
||||
# Calculate plateau log.OD from fitted parameters
|
||||
plateau = function(fitted.well, digits = Inf){
|
||||
if(length(fitted.well@fit.par) == 0)
|
||||
return(NA)
|
||||
|
||||
plat = fitted.well@fit.par$A + fitted.well@fit.par$b
|
||||
|
||||
if (!is.numeric(plat)) {
|
||||
plat = NA
|
||||
} else {
|
||||
plat = round(plat, digits)
|
||||
}
|
||||
return(plat)
|
||||
}
|
||||
|
||||
# Calculate baseline log.OD from fitted parameters
|
||||
baseline = function(fitted.well, digits = Inf){
|
||||
if(length(fitted.well@fit.par) == 0)
|
||||
return(NA)
|
||||
|
||||
base = fitted.well@fit.par$b
|
||||
|
||||
# If A (plateau OD) is invalid, return NA.
|
||||
if (!is.numeric(fitted.well@fit.par$A))
|
||||
base = NA
|
||||
# If b (baseline OD) is invalid but plateau OD was valid, return zero.
|
||||
else if (!is.numeric(base))
|
||||
base = 0
|
||||
else{
|
||||
base = round(base, digits)
|
||||
}
|
||||
return(base)
|
||||
}
|
||||
|
||||
# Calculate log.OD at inoculation from fitted parameters
|
||||
inoc.log.OD = function(fitted.well, digits = Inf){
|
||||
# Evaluated the fitted model at the inoculation timepoint (should be zero from using <start.times> from table2wells.R)
|
||||
if (is.null(well.eval(fitted.well)))
|
||||
return(NA)
|
||||
else{
|
||||
inoc.time = fitted.well@screen.data$Time[fitted.well@start.index]
|
||||
inoc.log.OD = well.eval(fitted.well, inoc.time)
|
||||
if (is.na(inoc.log.OD)) inoc.log.OD = fitted.well@fit.par$b # need this in a special case: loess fits with start.index = 1
|
||||
return(round(inoc.log.OD, digits))
|
||||
}
|
||||
}
|
||||
|
||||
# Calculate max log.OD from model fit
|
||||
max.log.OD = function(fitted.well, digits = Inf, ...){
|
||||
# Evaluated the fitted model at the final timepoint (just the last valid timepoint in the experiment)
|
||||
if (is.null(well.eval(fitted.well)))
|
||||
return(NA)
|
||||
else{
|
||||
return(round(max(well.eval(fitted.well),na.rm=T), digits))
|
||||
}
|
||||
}
|
||||
|
||||
# Calculate projected growth: plateau minus the inoculated log.OD
|
||||
projected.growth = function(fitted.well,digits=Inf) {
|
||||
plateau(fitted.well,digits) - inoc.log.OD(fitted.well,digits)
|
||||
}
|
||||
|
||||
|
||||
# Calculate projected growth: plateau minus the inoculated log.OD
|
||||
projected.growth.OD = function(fitted.well,constant.added,digits=Inf) {
|
||||
value = unlog(plateau(fitted.well),constant.added) - unlog(inoc.log.OD(fitted.well),constant.added)
|
||||
round(value,digits)
|
||||
}
|
||||
|
||||
# Calculate achieved growth: max.log.OD minus the inoculated log.OD
|
||||
achieved.growth = function(fitted.well,digits=Inf) {
|
||||
max.log.OD(fitted.well,digits) - inoc.log.OD(fitted.well,digits)
|
||||
}
|
||||
|
||||
# Calculate projected growth: plateau minus the inoculated log.OD
|
||||
achieved.growth.OD = function(fitted.well,constant.added,digits=Inf) {
|
||||
value = unlog(max.log.OD(fitted.well),constant.added) - unlog(inoc.log.OD(fitted.well),constant.added)
|
||||
round(value,digits)
|
||||
}
|
||||
|
||||
# Did the curve come close to the plateau OD during the experiment?
|
||||
reach.plateau = function(fitted.well, cutoff = 0.75){
|
||||
plat = plateau(fitted.well)
|
||||
inoc = inoc.log.OD(fitted.well)
|
||||
final = max.log.OD(fitted.well)
|
||||
|
||||
if (!is.na(final)){
|
||||
# If the plateau is the same as the OD at inoculation, return TRUE
|
||||
if ((plat - inoc) == 0)
|
||||
return(T)
|
||||
# If the difference between the final OD and inoculation OD is at least a certain proportion
|
||||
# <cutoff> of the difference between the plateau and inoculated ODs, return TRUE.
|
||||
else
|
||||
return((final - inoc) / (plat - inoc) > cutoff)
|
||||
}
|
||||
else
|
||||
return(T)
|
||||
# If no final OD was calculated (if curve was not fit properly) just return T.
|
||||
}
|
||||
|
||||
# Calculate the lag time from the fitted OD
|
||||
lag.time = function(fitted.well, digits = Inf, ...){
|
||||
if(length(fitted.well@fit.par) == 0)
|
||||
return(NA)
|
||||
|
||||
fitted.well@fit.par$lam
|
||||
}
|
||||
|
||||
# new params for GCAT 4.0
|
||||
# Get amplitude
|
||||
amplitude = function(fitted.well){
|
||||
if(length(fitted.well@fit.par) == 0)
|
||||
return(NA)
|
||||
|
||||
return(fitted.well@fit.par$A)
|
||||
}
|
||||
|
||||
# Get shape parameter
|
||||
shape.par = function(fitted.well){
|
||||
if(length(fitted.well@fit.par) == 0)
|
||||
return(NA)
|
||||
ifelse(is.null(fitted.well@fit.par$v), NA, fitted.well@fit.par$v)
|
||||
}
|
||||
|
||||
# Get standard error of the maximum specific growth rate value
|
||||
max.spec.growth.rate.SE = function(fitted.well, ...){
|
||||
if(length(fitted.well@fit.std.err) == 0)
|
||||
return(NA)
|
||||
ifelse(is.null(fitted.well@fit.std.err$u), NA, fitted.well@fit.std.err$u)
|
||||
}
|
||||
|
||||
# Get standard error of the lag time value
|
||||
lag.time.SE = function(fitted.well, ...){
|
||||
if(length(fitted.well@fit.std.err) == 0)
|
||||
return(NA)
|
||||
ifelse(is.null(fitted.well@fit.std.err$lam), NA, fitted.well@fit.std.err$lam)
|
||||
}
|
||||
|
||||
# Get standard error of the shape parameter
|
||||
shape.par.SE = function(fitted.well){
|
||||
if(length(fitted.well@fit.std.err) == 0)
|
||||
return(NA)
|
||||
ifelse(is.null(fitted.well@fit.std.err$v), NA, fitted.well@fit.std.err$v)
|
||||
}
|
||||
|
||||
# Get standard error of the amplitude
|
||||
amplitude.SE = function(fitted.well){
|
||||
if(length(fitted.well@fit.std.err) == 0)
|
||||
return(NA)
|
||||
ifelse(is.null(fitted.well@fit.std.err$A), NA, fitted.well@fit.std.err$A)
|
||||
}
|
||||
|
||||
# Get standard error of the baseline value
|
||||
baseline.SE = function(fitted.well){
|
||||
if(length(fitted.well@fit.std.err) == 0)
|
||||
return(NA)
|
||||
ifelse(is.null(fitted.well@fit.std.err$b), NA, fitted.well@fit.std.err$b)
|
||||
}
|
||||
|
||||
# Calulate the inflection time value
|
||||
inflection.time = function(well){
|
||||
if (length(well@loess) == 0 && length(well@nls) == 0) return(NA) # can' compute inflection time in the absence of a fit
|
||||
data = data.from(well)
|
||||
Time = data[,1]
|
||||
t = seq(from = min(Time), to = max(Time), by = (max(Time)-min(Time))/1000)
|
||||
y = well.eval(well,t)
|
||||
if (is.null(y)) return(NA)
|
||||
delta.t = diff(t)
|
||||
dydt = diff(y)/delta.t
|
||||
infl.index = which.max(dydt)
|
||||
t[infl.index]
|
||||
}
|
||||
|
||||
@ -1,36 +1,36 @@
|
||||
#Copyright 2012 The Board of Regents of the University of Wisconsin System.
|
||||
#Contributors: Jason Shao, James McCurdy, Enhai Xie, Adam G.W. Halstead,
|
||||
#Michael H. Whitney, Nathan DiPiazza, Trey K. Sato and Yury V. Bukhman
|
||||
#
|
||||
#This file is part of GCAT.
|
||||
#
|
||||
#GCAT is free software: you can redistribute it and/or modify
|
||||
#it under the terms of the GNU Lesser General Public License as published by
|
||||
#the Free Software Foundation, either version 3 of the License, or
|
||||
#(at your option) any later version.
|
||||
#
|
||||
#GCAT is distributed in the hope that it will be useful,
|
||||
#but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
#GNU Lesser General Public License for more details.
|
||||
#
|
||||
#You should have received a copy of the GNU Lesser General Public License
|
||||
#along with GCAT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
# Wrapper for sapply to use lapply over an array, conserving the dimensions.
|
||||
aapply = function(x, FUN,...){
|
||||
dim.values = dim(x)
|
||||
dim.names = dimnames(x)
|
||||
x = lapply(x, function(x){FUN(x,...)})
|
||||
dim(x) = dim.values
|
||||
dimnames(x) = dim.names
|
||||
return(x)
|
||||
}
|
||||
|
||||
# A function to manually create an unchecked exception.
|
||||
exception = function(class, msg)
|
||||
{
|
||||
cond <- simpleError(msg)
|
||||
class(cond) <- c(class, "MyException", class(cond))
|
||||
stop(cond)
|
||||
}
|
||||
#Copyright 2012 The Board of Regents of the University of Wisconsin System.
|
||||
#Contributors: Jason Shao, James McCurdy, Enhai Xie, Adam G.W. Halstead,
|
||||
#Michael H. Whitney, Nathan DiPiazza, Trey K. Sato and Yury V. Bukhman
|
||||
#
|
||||
#This file is part of GCAT.
|
||||
#
|
||||
#GCAT is free software: you can redistribute it and/or modify
|
||||
#it under the terms of the GNU Lesser General Public License as published by
|
||||
#the Free Software Foundation, either version 3 of the License, or
|
||||
#(at your option) any later version.
|
||||
#
|
||||
#GCAT is distributed in the hope that it will be useful,
|
||||
#but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
#GNU Lesser General Public License for more details.
|
||||
#
|
||||
#You should have received a copy of the GNU Lesser General Public License
|
||||
#along with GCAT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
# Wrapper for sapply to use lapply over an array, conserving the dimensions.
|
||||
aapply = function(x, FUN,...){
|
||||
dim.values = dim(x)
|
||||
dim.names = dimnames(x)
|
||||
x = lapply(x, function(x){FUN(x,...)})
|
||||
dim(x) = dim.values
|
||||
dimnames(x) = dim.names
|
||||
return(x)
|
||||
}
|
||||
|
||||
# A function to manually create an unchecked exception.
|
||||
exception = function(class, msg)
|
||||
{
|
||||
cond <- simpleError(msg)
|
||||
class(cond) <- c(class, "MyException", class(cond))
|
||||
stop(cond)
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,42 @@
|
||||
% Generated by roxygen2 (4.1.1): do not edit by hand
|
||||
% Please edit documentation in R/slope.analysis.R
|
||||
\name{check.slopes}
|
||||
\alias{check.slopes}
|
||||
\title{Use slope estimates to check growth curves for tanking and OD jumps #}
|
||||
\usage{
|
||||
check.slopes(input.well, check.start = 22, fall.cutoff = -0.0025,
|
||||
remove.jumps = F, jump.multipliers = -c(15, 500, 10), tank.cutoff = 1,
|
||||
tank.limit = 6, silent = T, draw = T)
|
||||
}
|
||||
\arguments{
|
||||
\item{input.well}{object of class \code{well} to check the slopes for}
|
||||
|
||||
\item{check.start}{which timepoint should checking for jumps and tanking start at? this is included because early timepoints can be unstable.}
|
||||
|
||||
\item{fall.cutoff}{what downward slope should constitute a fall in OD?}
|
||||
|
||||
\item{remove.jumps}{should the program remove OD jumps? default F (just report them) -
|
||||
should be set to T if data contains distinct jumps in OD that need to be eliminated
|
||||
otherwise, this might be too stringent and will result in loss of data.}
|
||||
|
||||
\item{jump.multipliers}{multipliers of fall.cutoff that determine whether a curve jumps up or down (see methods 1 and 2, below)}
|
||||
|
||||
\item{tank.cutoff}{what proportion of the maximum OD can the curve go below until it is considered tanking?}
|
||||
|
||||
\item{tank.limit}{how many timepoints in a row can have falling slopes until the curve is marked as tanking?}
|
||||
|
||||
\item{silent}{output to R console?}
|
||||
|
||||
\item{draw}{plot growth curve with curve checking details?}
|
||||
}
|
||||
\description{
|
||||
Use slope estimates to check growth curves for tanking and OD jumps #
|
||||
}
|
||||
\details{
|
||||
Uses the functions <data.from> and <well.name> (see well.class.R)
|
||||
|
||||
Fills the "curve.par" slot in the well with the starting index of tanking (NA if none is found)
|
||||
|
||||
Changed default values to parameters to account for settling
|
||||
}
|
||||
|
||||
@ -0,0 +1,29 @@
|
||||
% Generated by roxygen2 (4.1.1): do not edit by hand
|
||||
% Please edit documentation in R/plot.fit.R
|
||||
\name{create.heatmap}
|
||||
\alias{create.heatmap}
|
||||
\title{Create a heat map of a plate}
|
||||
\usage{
|
||||
create.heatmap(fitted.well.array, attribute, MinMax = NA, unlog = NULL)
|
||||
}
|
||||
\arguments{
|
||||
\item{fitted.well.array}{matrix containing well array object data}
|
||||
|
||||
\item{attribute}{the data type we should use to create a heatmap}
|
||||
|
||||
\item{MinMax}{The specific range for the heatmap.}
|
||||
|
||||
\item{unlog}{transform values to linear scale}
|
||||
}
|
||||
\value{
|
||||
path of heatmap pdf file
|
||||
}
|
||||
\description{
|
||||
Create a heat map of a plate
|
||||
}
|
||||
\details{
|
||||
This function is used to create a heatmap using
|
||||
specific growth, total growth, or lag time
|
||||
for each well on a plate.
|
||||
}
|
||||
|
||||
@ -0,0 +1,17 @@
|
||||
% Generated by roxygen2 (4.1.1): do not edit by hand
|
||||
% Please edit documentation in R/fit.model.R
|
||||
\name{fit.nls.model}
|
||||
\alias{fit.nls.model}
|
||||
\title{Fit nls model to a well using a specified model}
|
||||
\usage{
|
||||
fit.nls.model(input.well, model)
|
||||
}
|
||||
\arguments{
|
||||
\item{input.well}{object of class well}
|
||||
|
||||
\item{model}{object of class model, e.g. richards, gompertz or logistic}
|
||||
}
|
||||
\description{
|
||||
Fit nls model to a well using a specified model
|
||||
}
|
||||
|
||||
@ -1,30 +1,20 @@
|
||||
% Generated by roxygen2 (4.1.1): do not edit by hand
|
||||
% Please edit documentation in R/GCAT.main.R
|
||||
\docType{package}
|
||||
\name{GCAT}
|
||||
\alias{GCAT}
|
||||
\title{
|
||||
Growth Curve Analysis Tool
|
||||
}
|
||||
\alias{GCAT-package}
|
||||
\title{GCAT: Growth Curve Analysis Tool}
|
||||
\description{
|
||||
Mathematical modeling and parameter estimation of high volume microbial growth data.
|
||||
}
|
||||
\details{
|
||||
GCAT utilizes the \code{\link{nls}} function in the R base package to fit logistic and Richards models to
|
||||
growth curve data. Input is in .csv format and analysis is accessed using \code{\link{gcat.analysis.main}}
|
||||
or \code{\link{gcat.fit.main}}. Output is in .txt and .pdf format, and is accessed using \code{\link{gcat.analysis.main}}
|
||||
or \code{\link{gcat.output.main}}.
|
||||
GCAT input is in .csv format. GCAT analysis is accessed using \code{\link{gcat.analysis.main}}
|
||||
|
||||
\tabular{ll}{
|
||||
Version: \tab 5.0\cr
|
||||
Depends: \tab pheatmap, gplots\cr
|
||||
License: \tab LGPL-3\cr
|
||||
Date: \tab 2014-02-10\cr
|
||||
}
|
||||
GCAT utilizes the \code{\link[stats]{nls}} function in the R stats package to fit logistic, Gompertz and Richards models to growth curve
|
||||
data. Best model is selected automatically. Alternatively, the user may choose LOESS local regression fits, implemented using
|
||||
\code{\link[stats]{loess}} function in the R stats package
|
||||
|
||||
Internally, the data are stored in an array of \linkS4class{well} objects
|
||||
}
|
||||
\author{
|
||||
Jason Shao\cr
|
||||
Nate DiPiazza\cr
|
||||
Yury Bukhman\cr
|
||||
Minh Bui\cr
|
||||
|
||||
Maintainer: Yury Bukhman
|
||||
}
|
||||
@ -0,0 +1,15 @@
|
||||
% Generated by roxygen2 (4.1.1): do not edit by hand
|
||||
% Please edit documentation in R/table2well.R
|
||||
\name{gcat.append.arrays}
|
||||
\alias{gcat.append.arrays}
|
||||
\title{Function to combine two well array datasets by plate}
|
||||
\usage{
|
||||
gcat.append.arrays(...)
|
||||
}
|
||||
\arguments{
|
||||
\item{...}{any number of array objects as long as they are all output straight from <load.data>}
|
||||
}
|
||||
\description{
|
||||
This function can append together arrays created using <load.data>
|
||||
}
|
||||
|
||||
@ -1,53 +0,0 @@
|
||||
\name{gcat.set.constants}
|
||||
\alias{gcat.set.constants}
|
||||
\title{
|
||||
Set global constants for GCAT analysis package
|
||||
}
|
||||
\description{
|
||||
Sets global constants, mostly regarding issues in input file format, for GCAT analysis.
|
||||
}
|
||||
\usage{
|
||||
gcat.set.constants(plate.nrow = 8, plate.ncol = 12, input.skip.lines = 0, time.format = "\%Y-\%m-\%d \%H:\%M:\%S",
|
||||
multi.column.headers = c("Plate ID", "Well", "OD", "Time"), single.column.headers = c("", "A1"),
|
||||
xlsx.data.headers = c("Plate ID", "Well positions"), xlsx.layout.sheet = "Plate layout",
|
||||
layout.sheet.headers = c("Strain", "Media Definition"))
|
||||
}
|
||||
\arguments{
|
||||
\item{plate.nrow}{
|
||||
Number of rows present in each plate of input data. Default 8 (A-H)
|
||||
}
|
||||
\item{plate.ncol}{
|
||||
Number of columns present in each plate of input data. Default 12 (1-12)
|
||||
}
|
||||
\item{input.skip.lines}{
|
||||
Number of lines to skip at the top when reading input data files.
|
||||
}
|
||||
\item{time.format}{
|
||||
Either a character describing the format used to convert timestamps
|
||||
in the input to numbers representing number of seconds (see \code{\link{strptime}}), or a
|
||||
factor to divide entries in the \code{Time} column by to get the number of hours.
|
||||
}
|
||||
\item{multi.column.headers}{
|
||||
A character vector describing the names of the columns for
|
||||
Plate ID, Well ID, Cellular density measurements and Time, respectively, in the multi-plate (long) format.
|
||||
}
|
||||
\item{single.column.headers}{
|
||||
A character vector describing the name of the Time column and the first well data in the single plate (wide) format.
|
||||
}
|
||||
\item{xlsx.data.headers}{
|
||||
For .xlsx data only, a vector describing possible entries in the upper left cell marking worksheets in each
|
||||
workbook as containing data. .csv files don't have multiple worksheets and are assumed to contain useable data.
|
||||
}
|
||||
\item{xlsx.layout.sheet}{
|
||||
For .xlsx data only, the name of the worksheet containing plate layout information. .csv files use a separate layout file.
|
||||
}
|
||||
\item{layout.sheet.headers}{
|
||||
A character vector describing the name of the Strain and Media definiton columns, respectively, in the plate layout file.
|
||||
}
|
||||
}
|
||||
\value{
|
||||
NULL
|
||||
}
|
||||
\author{
|
||||
Jason Shao
|
||||
}
|
||||
@ -0,0 +1,25 @@
|
||||
% Generated by roxygen2 (4.1.1): do not edit by hand
|
||||
% Please edit documentation in R/table2well.R
|
||||
\name{gcat.start.times}
|
||||
\alias{gcat.start.times}
|
||||
\title{Convert timestamps to hours from start and sort timepoints
|
||||
This function acts on a single well and modifies the raw data stored in slot "screen.data"}
|
||||
\usage{
|
||||
gcat.start.times(input.well, time.input, start.index = 2)
|
||||
}
|
||||
\arguments{
|
||||
\item{input.well}{an object of class well}
|
||||
|
||||
\item{time.input}{specifies time format in the input. allowed values are "%S", for seconds, "%d", for days, or anything complying with
|
||||
ISO C / POSIX standards; see <strptime>.}
|
||||
|
||||
\item{start.index}{which timepoint should be used as the starting time at inoculation?}
|
||||
}
|
||||
\description{
|
||||
Convert timestamps to hours from start and sort timepoints
|
||||
This function acts on a single well and modifies the raw data stored in slot "screen.data"
|
||||
}
|
||||
\details{
|
||||
note: reading directly from excel to R results in timestamps being converted to days.
|
||||
}
|
||||
|
||||
@ -0,0 +1,16 @@
|
||||
% Generated by roxygen2 (4.1.1): do not edit by hand
|
||||
% Please edit documentation in R/class.well.R
|
||||
\docType{methods}
|
||||
\name{length,well-method}
|
||||
\alias{length,well-method}
|
||||
\title{Get the number of data points in a well}
|
||||
\usage{
|
||||
\S4method{length}{well}(x)
|
||||
}
|
||||
\arguments{
|
||||
\item{x}{object of class \code{well}}
|
||||
}
|
||||
\description{
|
||||
Get the number of data points in a well
|
||||
}
|
||||
|
||||
@ -0,0 +1,43 @@
|
||||
% Generated by roxygen2 (4.1.1): do not edit by hand
|
||||
% Please edit documentation in R/normalize.and.transform.R
|
||||
\name{normalize.ODs}
|
||||
\alias{normalize.ODs}
|
||||
\title{Normalize OD readings for an entire array of well objects}
|
||||
\usage{
|
||||
normalize.ODs(well.array, normalize.method = "default", blank.value = NULL,
|
||||
start.index = 2, add.constant = 1)
|
||||
}
|
||||
\arguments{
|
||||
\item{well.array}{an array of well objects.}
|
||||
|
||||
\item{normalize.method}{see Details}
|
||||
|
||||
\item{blank.value}{user can enter a blank OD measurement for uninoculated wells. if NULL, defaults to the value of the first OD measurement of each well.}
|
||||
|
||||
\item{start.index}{which timepoint should be used as the first one after inoculation (defaults to the 2th one)}
|
||||
|
||||
\item{add.constant}{add a numeric constant to all timepoints in all wells.}
|
||||
}
|
||||
\description{
|
||||
Normalize OD readings for an entire array of well objects
|
||||
}
|
||||
\details{
|
||||
Note: This function does not write any new OD values to the well objects in the array - it only
|
||||
fills the "norm" slot of each well object in the array with a value that will be subtracted
|
||||
from all OD measurements when returning data from the wells using the function <data.from> (see well.class.R)
|
||||
|
||||
These functions make use of <raw.data> which simply returns the raw time and OD of a well (also see well.class.R)
|
||||
|
||||
note this is the only normalization function that acts on an entire array instead of an individual well.
|
||||
|
||||
normalize.method settings:
|
||||
\describe{
|
||||
\item{default}{subtracts the blank OD (either specified by <blank.value> or taken from the first timepoint as default)
|
||||
of each well from all timepoints in that well}
|
||||
\item{average.blank}{subtracts the mean of all first OD timepoints on a plate from all timepoints in all wells on that plate}
|
||||
\item{average.first}{takes the mean of the difference between the OD of the specified <start> timepoint and the first timepoint of all wells on a plate
|
||||
and subtracts this value from all timepoints in all wells on that plate}
|
||||
\item{anything else}{do nothing}
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,43 @@
|
||||
% Generated by roxygen2 (4.1.1): do not edit by hand
|
||||
% Please edit documentation in R/class.well.R
|
||||
\docType{methods}
|
||||
\name{plot,well,missing-method}
|
||||
\alias{plot,well,missing-method}
|
||||
\title{A plot method for well}
|
||||
\usage{
|
||||
\S4method{plot}{well,missing}(x, y, constant.added = 1, xlim = NULL,
|
||||
ylim = NULL, well.number = NULL, scale = 1, number.points = T,
|
||||
draw.symbols = F, show.text = T, show.calc = T, draw.guess = NULL,
|
||||
...)
|
||||
}
|
||||
\arguments{
|
||||
\item{x}{object of class well}
|
||||
|
||||
\item{y}{not used}
|
||||
|
||||
\item{constant.added}{used to readjust for the constant added during the log transform: log.OD = log(OD - blank + constant.added)}
|
||||
|
||||
\item{xlim}{x axis limits, vector of length 2}
|
||||
|
||||
\item{ylim}{y axis limits, vector of length 2}
|
||||
|
||||
\item{well.number}{the number of the well in an array of wells}
|
||||
|
||||
\item{scale}{determines the font scale for the entire graph. all cex values are calculated from this}
|
||||
|
||||
\item{number.points}{should points be labeled with numeric indices?}
|
||||
|
||||
\item{draw.symbols}{should <check.slopes> be called on the well and markings drawn on the graph?}
|
||||
|
||||
\item{show.text}{show R^2 and growth curve parameters as text on the plot}
|
||||
|
||||
\item{show.calc}{draw lines that illustrate growth curve parameters}
|
||||
|
||||
\item{draw.guess}{initial guess model. Drawn if specified}
|
||||
|
||||
\item{...}{additional arguments passed to the generic plot function}
|
||||
}
|
||||
\description{
|
||||
A plot method for well
|
||||
}
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue