Migrated from GitHub

.gitattributes

@@ -57,3 +57,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/docs/deps/font-awesome-6.5.2/webfonts/fa-brands-400.ttf filter=lfs diff=lfs merge=lfs -text
+data/docs/deps/font-awesome-6.5.2/webfonts/fa-brands-400.woff2 filter=lfs diff=lfs merge=lfs -text
+data/docs/deps/font-awesome-6.5.2/webfonts/fa-solid-900.ttf filter=lfs diff=lfs merge=lfs -text
+data/docs/deps/font-awesome-6.5.2/webfonts/fa-solid-900.woff2 filter=lfs diff=lfs merge=lfs -text

data/.Rbuildignore

@@ -0,0 +1,20 @@
+^Meta$
+^doc$
+^docs$
+^LICENSE\.md$
+^.*\.Rproj$
+^\.Rproj\.user$
+^R/issues\.R$
+CONDUCT.md
+README.Rmd
+README_files/*
+R/scratch.R
+^cran-comments\.md$
+^CRAN-RELEASE$
+^_pkgdown\.yml$
+^pkgdown$
+^CRAN-SUBMISSION$
+\.github/*
+^\.github$
+^data-raw$
+^r/photosynthesis-2d\.R$

data/CONDUCT.md

@@ -0,0 +1,25 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who 
+contribute through reporting issues, posting feature requests, updating documentation,
+submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for
+everyone, regardless of level of experience, gender, gender identity and expression,
+sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or
+imagery, derogatory comments or personal attacks, trolling, public or private harassment,
+insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments,
+commits, code, wiki edits, issues, and other contributions that are not aligned to this 
+Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed 
+from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by 
+opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the Contributor Covenant 
+(http:contributor-covenant.org), version 1.0.0, available at 
+http://contributor-covenant.org/version/1/0/0/

data/DESCRIPTION

@@ -0,0 +1,84 @@
+Package: photosynthesis
+Version: 2.1.5
+Date: 2024-11-23
+Title: Tools for Plant Ecophysiology & Modeling
+Authors@R: c(
+    person("Joseph", "Stinziano", email = "[email protected]", role = "aut", comment = c(ORCID = "0000-0002-7628-4201")),
+    person("Cassaundra", "Roback", email = "[email protected]", role = "aut"),
+    person("Demi", "Sargent", email = "[email protected]", role = "aut"),
+    person("Bridget", "Murphy", email = "[email protected]", role = "aut"),
+    person("Patrick", "Hudson", email = "[email protected]", role = c("aut", "dtc")), 
+    person("Chris", "Muir", email = "[email protected]", role = c("aut", "cre"), comment = c(ORCID = "0000-0003-2555-3878"))
+    )
+Depends: R (>= 4.0.0),
+         ggplot2 (>= 3.4.0),
+         minpack.lm (>= 1.2-1),
+         units (>= 0.6.6)
+Imports: checkmate (>= 2.0.0),
+         crayon (>= 1.3.4),
+         dplyr (>= 0.8.5),
+         furrr (>= 0.1.0),
+         glue (>= 1.4.0),
+         graphics (>= 4.0.0),
+         grDevices (>= 4.0.0),
+         gunit (>= 1.0.2),
+         lifecycle (>= 1.0.0),
+         magrittr (>= 1.5.0),
+         methods (>= 3.5.0),
+         nlme (>= 3.1-147),
+         progress (>= 1.2.0),
+         purrr (>= 0.3.3),
+         readr (>= 2.0.0),
+         rlang (>= 0.4.6),
+         stats (>= 4.0.0),
+         stringr (>= 1.4.0),
+         tealeaves (>= 1.0.5),
+         utils (>= 4.0.0)
+Suggests: 
+    brms,
+    broom,
+    future,
+    knitr,
+    rmarkdown,
+    testthat,
+    tibble,
+    tidyr,
+    tidyselect
+Description: Contains modeling and analytical tools for plant ecophysiology.
+    MODELING: Simulate C3 photosynthesis using the Farquhar, von Caemmerer,
+    Berry (1980) <doi:10.1007/BF00386231> model as described in Buckley and
+    Diaz-Espejo (2015) <doi:10.1111/pce.12459>. It uses units to ensure that
+    parameters are properly specified and transformed before calculations.
+    Temperature response functions get automatically "baked" into all
+    parameters based on leaf temperature following Bernacchi et al. (2002)
+    <doi:10.1104/pp.008250>. The package includes boundary layer, cuticular,
+    stomatal, and mesophyll conductances to CO2, which each can vary on the
+    upper and lower portions of the leaf. Use straightforward functions to
+    simulate photosynthesis over environmental gradients such as Photosynthetic
+    Photon Flux Density (PPFD) and leaf temperature, or over trait gradients
+    such as CO2 conductance or photochemistry. 
+    ANALYTICAL TOOLS: Fit ACi (Farquhar et al. (1980) <doi:10.1007/BF00386231>)
+    and AQ curves (Marshall & Biscoe (1980) <doi:10.1093/jxb/31.1.29>),
+    temperature responses (Heskel et al. (2016) <doi:10.1073/pnas.1520282113>;
+    Kruse et al. (2008) <doi:10.1111/j.1365-3040.2008.01809.x>, Medlyn et al.
+    (2002) <doi:10.1046/j.1365-3040.2002.00891.x>, Hobbs et al. (2013)
+    <doi:10.1021/cb4005029>), respiration in the light (Kok (1956)
+    <doi:10.1016/0006-3002(56)90003-8>, Walker & Ort (2015) <doi:10.1111/pce.12562>,
+    Yin et al. (2009) <doi:10.1111/j.1365-3040.2009.01934.x>, Yin et al. (2011)
+    <doi:10.1093/jxb/err038>), mesophyll conductance (Harley et al. (1992)
+    <doi:10.1104/pp.98.4.1429>), pressure-volume curves (Koide et al. (2000)
+    <doi:10.1007/978-94-009-2221-1_9>, Sack et al. (2003)
+    <doi:10.1046/j.0016-8025.2003.01058.x>, Tyree et al. (1972)
+    <doi:10.1093/jxb/23.1.267>), hydraulic vulnerability curves (Ogle et al. (2009)
+    <doi:10.1111/j.1469-8137.2008.02760.x>, Pammenter et al. (1998)
+    <doi:10.1093/treephys/18.8-9.589>), and tools for running sensitivity
+    analyses particularly for variables with uncertainty (e.g. g_mc(), gamma_star(),
+    R_d()).
+License: MIT + file LICENSE
+Encoding: UTF-8
+LazyData: true
+RoxygenNote: 7.3.2
+VignetteBuilder: knitr
+URL: https://github.com/cdmuir/photosynthesis
+BugReports: https://github.com/cdmuir/photosynthesis/issues
+Roxygen: list(markdown = TRUE)

data/LICENSE

@@ -0,0 +1,2 @@
+YEAR: 2024
+COPYRIGHT HOLDER: Joseph R. Stinziano, Cassaundra Roback, Demi Gamble, Bridget Murphy, Patrick Hudson, & Christopher D. Muir

data/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2024 Joseph R. Stinziano, Cassaundra Roback, Demi Gamble, Bridget Murphy, Patrick Hudson, & Christopher D. Muir
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/NAMESPACE

@@ -0,0 +1,112 @@
+# Generated by roxygen2: do not edit by hand
+
+export(A_demand)
+export(A_supply)
+export(FvCB)
+export(J)
+export(W_carbox)
+export(W_regen)
+export(W_tpu)
+export(analyze_sensitivity)
+export(aq_response)
+export(bake)
+export(bake_par)
+export(calculate_j)
+export(calculate_jmax)
+export(compile_data)
+export(compute_sensitivity)
+export(constants)
+export(enviro_par)
+export(fit_PV_curve)
+export(fit_aci_response)
+export(fit_aq_response)
+export(fit_aq_response2)
+export(fit_g_mc_variableJ)
+export(fit_gs_model)
+export(fit_hydra_vuln_curve)
+export(fit_many)
+export(fit_photosynthesis)
+export(fit_r_light2)
+export(fit_r_light_WalkerOrt)
+export(fit_r_light_kok)
+export(fit_r_light_yin)
+export(fit_t_response)
+export(get_all_models)
+export(get_default_model)
+export(gs_mod_ballberry)
+export(gs_mod_leuning)
+export(gs_mod_opti)
+export(gs_mod_optifull)
+export(leaf_par)
+export(make_bakepar)
+export(make_constants)
+export(make_enviropar)
+export(make_leafpar)
+export(marshall_biscoe_1980)
+export(parameter_names)
+export(photo)
+export(photoinhibition)
+export(photosynthesis)
+export(ppm2pa)
+export(print_graphs)
+export(read_li6800)
+export(read_licor)
+export(required_variables)
+export(simulate_error)
+export(t_response_arrhenius)
+export(t_response_arrhenius_kruse)
+export(t_response_arrhenius_medlyn)
+export(t_response_arrhenius_topt)
+export(t_response_calc_dS)
+export(t_response_calc_topt)
+export(t_response_heskel)
+export(t_response_mmrt)
+export(temp_resp1)
+export(temp_resp2)
+importFrom(dplyr,bind_rows)
+importFrom(ggplot2,aes)
+importFrom(ggplot2,annotate)
+importFrom(ggplot2,element_blank)
+importFrom(ggplot2,geom_hline)
+importFrom(ggplot2,geom_line)
+importFrom(ggplot2,geom_point)
+importFrom(ggplot2,geom_smooth)
+importFrom(ggplot2,geom_vline)
+importFrom(ggplot2,ggplot)
+importFrom(ggplot2,ggtitle)
+importFrom(ggplot2,labs)
+importFrom(ggplot2,scale_color_manual)
+importFrom(ggplot2,scale_colour_manual)
+importFrom(ggplot2,scale_y_continuous)
+importFrom(ggplot2,theme)
+importFrom(ggplot2,theme_bw)
+importFrom(grDevices,dev.off)
+importFrom(grDevices,jpeg)
+importFrom(grDevices,pdf)
+importFrom(graphics,par)
+importFrom(graphics,plot)
+importFrom(magrittr,"%<>%")
+importFrom(magrittr,"%>%")
+importFrom(methods,is)
+importFrom(minpack.lm,nls.lm.control)
+importFrom(minpack.lm,nlsLM)
+importFrom(nlme,lmList)
+importFrom(rlang,":=")
+importFrom(rlang,.data)
+importFrom(rlang,exec)
+importFrom(stats,coef)
+importFrom(stats,confint)
+importFrom(stats,deriv)
+importFrom(stats,lm)
+importFrom(stats,nls.control)
+importFrom(stats,optim)
+importFrom(stats,plogis)
+importFrom(stats,resid)
+importFrom(stats,rnorm)
+importFrom(stats,sd)
+importFrom(units,as_units)
+importFrom(units,drop_units)
+importFrom(units,set_units)
+importFrom(utils,read.csv)
+importFrom(utils,setTxtProgressBar)
+importFrom(utils,txtProgressBar)

data/NEWS.md

@@ -0,0 +1,101 @@
+# photosynthesis 2.1.5
+
+* Added `photoinhibition()` to light response models. This allows users to estimate photoinhibition at high light.
+
+# photosynthesis 2.1.4
+
+* Removed imports of unexported **tealeaves** functions using `:::` operator
+* `read_licor()` removes lines where parameter settings are changed between logging
+
+# photosynthesis 2.1.3
+
+* Added example LI6800 data set (inst/extdata/li6800_example) for unit testing `read_licor()`
+* Soft-deprecated `read_li6800()` in favor of `read_licor()`
+* Soft-deprecated `fit_many()` in favor of generic methods like `purrr::map()`
+
+# photosynthesis 2.1.2
+
+* Updated CITATION using `bibentry()` instead of `citEntry()`
+* Resolved **purrr** deprecations
+* removed `expect_no_condition()` from unit tests to resolved issue #12
+* Replaced `dplyr::progress_estimated()` with `progress::progress_bar()`
+* Fixed error in `photo(..., use_tealeaves = TRUE)`. User-defined changes in stomatal conductance ratio were not being passed to **tealeaves**.
+* Added evaporation (E) to `photo()` and `photosynthesis()` output when `use_tealeaves = TRUE`
+* Fixed issue with **lifecycle** badges
+* Added new function `simulate_error()` to simulate measurement error in gas exchange measurements.
+
+# photosynthesis 2.1.1
+
+* Added Bayesian options to fit light-response and light respiration models via `fit_photosynthesis(..., .method = "brms")`
+* Preferred method for fitting data to models is `fit_photosynthesis()` which performs all checks and manipulations prior to passing arguments to various `fit_` functions.
+* Deprecated `fit_r_light_kok()`, `fit_r_light_WalkerOrt()`, `fit_r_light_yin()` in favor of `fit_r_light2()`. The new function uses non-standard evaluation to replace variable names as in `dplyr::rename()`. It will also extend functionality to enable Bayesian fitting using **brms** and does not output a plot.
+* Added Bayesian fitting method to `fit_aq_response2()` using **brms** package.
+* Deprecated `fit_aq_response()` in favor of `fit_aq_response2()`. The new function uses non-standard evaluation to replace variable names as in `dplyr::rename()`. It will also extend functionality to enable Bayesian fitting using **brms** and does not output a plot.
+* Fixed bug with setting upper bound for search in `find_A()`
+* Addressed warnings about deprecated arguments in **tidyselect** and **ggplot2**
+* Added `C_i` (intercellular CO2 concentration) to output from `photo()` and `photosynthesis()`
+
+# photosynthesis 2.1.0
+
+* Commented out examples that took a long time to run
+* Added `progress` option to `fit_many()` to toggle progress bar
+* We removed large files from help subdirectory
+* Divided large vignette into smaller vignettes and removed figures to reduce file size
+* Updated CITATION
+* There is a new vignette on C3 photosynthesis modeling recommendations (modeling-recommendations)
+* Under the hood, many changes to `photosynthesis()`, but performance should be the same
+* Changed default `C_air` from 41 Pa to 420 umol/mol
+* Changed default `O` from 21.27565 kPa to 0.21 mol/mol
+* Added optional feature to calculate mesophyll conductance to CO2 (g_mc) as sum of internal airspace (`g_iasc`) and liquid-phase (`g_liqc`) conductances.
+* To avoid redundancy, `photo_parameters` is single source of truth for all input parameters to `photo()` and `photosynthesis()`.
+* Fixed error in `gc2gw()` and `gw2gc()` and migrated to **gunit** version 1.0.2. Legacy version used version for still air in boundary layer conductance conversions. The corrected version includes modification for laminar flow in the boundary layer. Legacy version can be obtained with option `use_legacy_version = TRUE`.
+* Changed default conductance units from `[umol / m ^ 2 / s / Pa]` to `[mol / m ^ 2 / s]`
+* Changed `<-` to `=` in many instances
+* Changed `%>%` to `|>` in many instances
+
+# photosynthesis 2.0.3
+
+* In the DESCRIPTION file, rewrote references in the form authors (year) <doi:...>
+* In the DESCRIPTION file, added () behind all function names
+* Added \value to .Rd files regarding exported methods for bake.Rd, bake_par.Rd, constants.Rd, enviro_par.Rd, leaf_par.Rd, parameter_names.Rd
+* Changed print() to stop() or message() in R/compile_data.R; R/fit_gs_model.R; R/fit_t_response.R; R/print_graphs.R
+* In R/print_graphs.R, added code to restore users' option for par()$mfrow
+* Removed "2020" from the field COPYRIGHT HOLDER in the LICENCE file
+* Updated link to Prometheus protocols in vignette
+* Stopped evaluating parallel example in vignette
+* Fixed tests that failed because of update to dependency **units** 0.8-0. (#7)
+
+# photosynthesis 2.0.1
+
+* for `temp_resp1` and `temp_resp2`, corrected reference. (#6)
+
+# photosynthesis 2.0.0
+
+* Added analytical tools for plant ecophysiology, including fitting stomatal
+conductance models, photosynthetic responses to light, CO2, and temperature,
+light respiration, as well as tools for performing sensitivity analyses.
+
+* Added tests for new functions.
+
+* Added new vignette to include examples of new analytical functions.
+
+# photosynthesis 1.0.2
+
+* Fixed bug with crossing parameters in `photosynthesis()` that was introduced when `use_tealeaves = TRUE` because of changes in the **tealeaves** package. This led to crossing all parameter values with all unique values of calculated `T_sky`, which was incorrect. Added unit tests to ensuring that crossing is done correctly under `tests/test-photosynthesis-crossing.R`
+* Fixed bug in `photosynthesis()` caused by new version of **dplyr**.
+* In `enviro_par()`, "sky" temperature (`T_sky`) can now be provided directly as a values (in K) or as a function (the default).
+* If `parallel = TRUE` in `photosynthesis()`, **future** uses `plan("multisession")` rather than `plan("multiprocess")`.
+* Added full URL for `CONDUCT.md` in README
+* Fixed cross-references in .Rd files
+
+# photosynthesis 1.0.1
+
+Release to be archived with revision of "Is amphistomy an adaptation to high light? Optimality models of stomatal traits along light gradients."
+
+[Blog post.](https://cdmuir.netlify.app/post/2019-05-21-phyteclub/)
+
+# photosynthesis 1.0.0
+
+Description: Simulate C$_3$ photosynthesis using the Farquhar, von Caemmerer, Berry (1980) model as described in Buckley and Diaz-Espejo (2015). It uses units to ensure that parameters are properly specified and transformed before calculations. Temperature response functions get automatically "baked" into all parameters based on leaf temperature following Bernacchi et al. (2002). The package includes boundary layer, cuticular, stomatal, and mesophyll conductances to CO$_2$, which each can vary on the upper and lower portions of the leaf. Use straightforward functions to simulate photosynthesis over environmental gradients such as Photosynthetic Photon Flux Density (PPFD) and leaf temperature, or over trait gradients such as CO$_2$ conductance or photochemistry. 
+
+* Added a `NEWS.md` file to track changes to the package.

data/R/FvCB.R

@@ -0,0 +1,182 @@
+#' Farquhar-von Caemmerer-Berry (FvCB) C3 photosynthesis model
+#'
+#' @inheritParams A_supply
+#'
+#' @return A list of four values with units umol CO2 / (m^2 s) of class `units`:
+#' \cr
+#' - `W_carbox`: Rubisco-limited assimilation rate \cr
+#' - `W_regen`: RuBP regeneration-limited assimilation rate \cr
+#' - `W_tpu`: TPU-limited assimilation rate \cr
+#' - `A`: minimum of W_carbox, W_regen, and W_tpu
+#'
+#' @details
+#'
+#' Equations following Buckley and Diaz-Espejo (2015): \cr
+#' \cr
+#' **Rubisco-limited assimilation rate:** \cr
+#' \cr
+#' \deqn{W_\mathrm{carbox} = V_\mathrm{c,max} C_\mathrm{chl} / (C_\mathrm{chl} + K_\mathrm{m})}{W_carbox = V_cmax C_chl / (C_chl + K_m)}
+#'
+#' where:
+#'
+#' \deqn{K_\mathrm{m} = K_\mathrm{C} (1 + O / K_\mathrm{O})}{K_m = K_c (1 + O / K_o)}
+#'
+#' **RuBP regeneration-limited assimilation rate:** \cr
+#' \cr
+#' \deqn{W_\mathrm{regen} = J C_\mathrm{chl} / (4 C_\mathrm{chl} + 8 \Gamma*)}{W_regen = J C_chl / (4 C_chl + 8 \Gamma*)}
+#'
+#' where \eqn{J} is a function of PPFD, obtained by solving the equation:
+#'
+#' \deqn{0 = \theta_J J ^ 2 - J (J_\mathrm{max} + \phi_J PPFD) + J_\mathrm{max} \phi_J PPFD}{0 = \theta_J J ^ 2 - J (J_max + \phi_J PPFD) + J_max \phi_J PPFD}
+#'
+#' **TPU-limited assimilation rate:** \cr
+#'
+#' \deqn{W_\mathrm{tpu} = 3 V_\mathrm{tpu} C_\mathrm{chl} / (C_\mathrm{chl} - \Gamma*)}{W_tpu = 3 V_tpu C_chl / (C_chl - \Gamma*)}
+#' \cr
+#' \tabular{lllll}{
+#' *Symbol* \tab *R* \tab *Description* \tab *Units* \tab *Default*\cr
+#' \eqn{C_\mathrm{chl}}{C_chl} \tab `C_chl` \tab chloroplastic CO2 concentration \tab Pa \tab input \cr
+#' \eqn{\Gamma*} \tab `gamma_star` \tab chloroplastic CO2 compensation point (T_leaf) \tab Pa \tab [calculated][bake] \cr
+#' \eqn{J_\mathrm{max}}{J_max} \tab `J_max` \tab potential electron transport (T_leaf) \tab \eqn{\mu}mol CO2 / (m\eqn{^2} s) \tab [calculated][bake] \cr
+#' \eqn{K_\mathrm{C}}{K_C} \tab `K_C` \tab Michaelis constant for carboxylation (T_leaf) \tab \eqn{\mu}mol / mol \tab [calculated][bake] \cr
+#' \eqn{K_\mathrm{O}}{K_O} \tab `K_O` \tab Michaelis constant for oxygenation (T_leaf) \tab \eqn{\mu}mol / mol \tab [calculated][bake] \cr
+#' \eqn{O} \tab `O` \tab atmospheric O2 concentration \tab kPa \tab 21.27565 \cr
+#' \eqn{\phi_J} \tab `phi_J` \tab initial slope of the response of J to PPFD \tab none \tab 0.331 \cr
+#' PPFD \tab `PPFD` \tab photosynthetic photon flux density \tab umol quanta / (m^2 s) \tab 1500 \cr
+#' \eqn{R_\mathrm{d}}{R_d} \tab `R_d` \tab nonphotorespiratory CO2 release (T_leaf) \tab \eqn{\mu}mol CO2 / (m\eqn{^2} s) \tab [calculated][bake] \cr
+#' \eqn{\theta_J} \tab `theta_J` \tab curvature factor for light-response curve \tab none \tab 0.825 \cr
+#' \eqn{V_\mathrm{c,max}}{V_c,max} \tab `V_cmax` \tab maximum rate of carboxylation (T_leaf) \tab \eqn{\mu}mol CO2 / (m\eqn{^2} s) \tab [calculated][bake] \cr
+#' \eqn{V_\mathrm{tpu}}{V_tpu} \tab `V_tpu` \tab rate of triose phosphate utilization (T_leaf) \tab \eqn{\mu}mol CO2 / (m\eqn{^2} s) \tab [calculated][bake]
+#' }
+#'
+#' @references
+#'
+#' Buckley TN and Diaz-Espejo A. 2015. Partitioning changes in photosynthetic
+#' rate into contributions from different variables. Plant, Cell & Environment
+#' 38: 1200-11.
+#'
+#' Farquhar GD, Caemmerer S, Berry JA. 1980. A biochemical model of
+#' photosynthetic CO2 assimilation in leaves of C3 species. Planta 149: 78–90.
+#'
+#' @examples
+#' bake_par = make_bakepar()
+#' constants = make_constants(use_tealeaves = FALSE)
+#' enviro_par = make_enviropar(use_tealeaves = FALSE)
+#' leaf_par = make_leafpar(use_tealeaves = FALSE)
+#' leaf_par = bake(leaf_par, enviro_par, bake_par, constants)
+#'
+#' pars = c(leaf_par, enviro_par, constants)
+#' C_chl = set_units(246.0161, umol / mol)
+#' FvCB(C_chl, pars)
+#' @export
+#'
+FvCB = function(C_chl, pars, unitless = FALSE) {
+  ret = list(
+    W_carbox = W_carbox(C_chl, pars, unitless),
+    W_regen = W_regen(C_chl, pars, unitless),
+    W_tpu = W_tpu(C_chl, pars, unitless)
+  )
+
+  # Ignore W_tpu if C_chl < gamma_star
+  if (C_chl > pars$gamma_star) {
+    ret$A = min(ret$W_carbox, ret$W_regen, ret$W_tpu)
+  } else {
+    ret$A = min(ret$W_carbox, ret$W_regen)
+  }
+  ret
+}
+#' Rubisco-limited assimilation rate
+#' @rdname FvCB
+#' @export
+W_carbox = function(C_chl, pars, unitless = FALSE) {
+  if (unitless) {
+    A = pars$V_cmax * C_chl / (C_chl + pars$K_C * (1 + 1e6 * pars$O / pars$K_O))
+  } else {
+    A = set_units(
+      pars$V_cmax * C_chl /
+        (C_chl + pars$K_C * (set_units(1) + pars$O / pars$K_O)),
+      umol / m^2 / s
+    )
+  }
+  A
+}
+#' RuBP regeneration-limited assimilation rate
+#' @rdname FvCB
+#' @export
+W_regen = function(C_chl, pars, unitless = FALSE) {
+  J = J(pars, unitless)
+  A = J * C_chl / (4 * C_chl + 8 * pars$gamma_star)
+  if (!unitless) A %<>% set_units(umol / m^2 / s)
+  A
+}
+#' TPU-limited assimilation rate
+#' @rdname FvCB
+#' @export
+W_tpu = function(C_chl, pars, unitless = FALSE) {
+  A = 3 * pars$V_tpu * C_chl / (C_chl - pars$gamma_star)
+  if (!unitless) A %<>% set_units(umol / m^2 / s)
+  A
+}
+#' J: Rate of electron transport (umol/m^2/s)
+#'
+#' @description Calculate the rate of electron transport as a function of photosynthetic photon flux density (PPFD).
+#'
+#' @inheritParams .get_gtc
+#'
+#' @return Value in \eqn{\mu}mol/ (m^2 s) of class `units`
+#'
+#' @details
+#'
+#' \eqn{J} as a function of PPFD is the solution to the quadratic expression:
+#'
+#' \deqn{0 = \theta_J J ^ 2 - J (J_\mathrm{max} + \phi_J PPFD) + J_\mathrm{max} \phi_J PPFD}{0 = \theta_J J ^ 2 - J (J_max + \phi_J PPFD) + J_max \phi_J PPFD}
+#'
+#' \tabular{lllll}{
+#' *Symbol* \tab *R* \tab *Description* \tab *Units* \tab *Default*\cr
+#' \eqn{J_\mathrm{max}}{J_max} \tab `J_max` \tab potential electron transport (T_leaf) \tab \eqn{\mu}mol CO2 / (m\eqn{^2} s) \tab [calculated][bake] \cr
+#' \eqn{\phi_J} \tab `phi_J` \tab initial slope of the response of J to PPFD \tab none \tab 0.331 \cr
+#' PPFD \tab `PPFD` \tab photosynthetic photon flux density \tab \eqn{\mu}mol quanta / (m^2 s) \tab 1500 \cr
+#' \eqn{\theta_J} \tab `theta_J` \tab curvature factor for light-response curve \tab none \tab 0.825
+#' }
+#'
+#' @examples
+#'
+#' library(magrittr)
+#' library(photosynthesis)
+#'
+#' bake_par = make_bakepar()
+#' constants = make_constants(use_tealeaves = FALSE)
+#' enviro_par = make_enviropar(use_tealeaves = FALSE)
+#' leaf_par = make_leafpar(use_tealeaves = FALSE)
+#' enviro_par$T_air = leaf_par$T_leaf
+#' leaf_par %<>% bake(enviro_par, bake_par, constants)
+#'
+#' pars = c(leaf_par, enviro_par, constants)
+#' J(pars, FALSE)
+#' @export
+#'
+J = function(pars, unitless = FALSE) {
+  if (!unitless) {
+    # drop units for root finding
+    pars$PPFD %<>% set_units(umol / m^2 / s) %>% drop_units()
+    pars$J_max %<>% set_units(umol / m^2 / s) %>% drop_units()
+    pars$phi_J %<>% drop_units()
+    pars$theta_J %<>% drop_units()
+  }
+
+  .f = function(J, PPFD, J_max, phi_J, theta_J) {
+    theta_J * J^2 - J * (J_max + phi_J * PPFD) + J_max * phi_J * PPFD
+  }
+
+  J_I = stats::uniroot(.f, c(0, pars$J_max),
+    PPFD = pars$PPFD, J_max =
+      pars$J_max,
+    phi_J = pars$phi_J, theta_J = pars$theta_J
+  )
+
+  J_I %<>% magrittr::use_series("root")
+
+  if (!unitless) J_I %<>% set_units(umol / m^2 / s)
+
+  J_I
+}

data/R/analyze_sensitivity.R

@@ -0,0 +1,148 @@
+#' Running 2-parameter sensitivity analyses
+#'
+#' @param data Dataframe
+#' @param funct Function to use - do not use parentheses
+#' @param test1 Input parameter to vary and test
+#' @param values1 Values of test1 to use
+#' @param test2 Input parameter to vary and test
+#' @param values2 Values of test2 to use
+#' @param element_out List element to compile
+#' @param ... Additional arguments required for the function
+#'
+#' @return analyze_sensitivity runs a 2-parameter sensitivity analysis.
+#' Note that any parameter value combinations that break the input function
+#' WILL break this function. For 1-parameter sensitivity analysis, use test1
+#' only.
+#'
+#' @importFrom rlang exec
+#' @importFrom rlang :=
+#' @export
+#'
+#' @examples
+#' \donttest{
+#' # Read in your data
+#' # Note that this data is coming from data supplied by the package
+#' # hence the complicated argument in read.csv()
+#' # This dataset is a CO2 by light response curve for a single sunflower
+#' data <- read.csv(system.file("extdata", "A_Ci_Q_data_1.csv",
+#'   package = "photosynthesis"
+#' ))
+#'
+#' # Define a grouping factor based on light intensity to split the ACi
+#' # curves
+#' data$Q_2 <- as.factor((round(data$Qin, digits = 0)))
+#'
+#' # Convert leaf temperature to K
+#' data$T_leaf <- data$Tleaf + 273.15
+#'
+#' # Run a sensitivity analysis on gamma_star and mesophyll conductance
+#' # at 25 Celsius for one individual curve
+#' # pars <- analyze_sensitivity(
+#' #   data = data[data$Q_2 == 1500, ],
+#' #   funct = fit_aci_response,
+#' #   varnames = list(
+#' #     A_net = "A",
+#' #     T_leaf = "T_leaf",
+#' #     C_i = "Ci",
+#' #     PPFD = "Qin"
+#' #   ),
+#' #   useg_mct = TRUE,
+#' #   test1 = "gamma_star25",
+#' #   element_out = 1,
+#' #   test2 = "g_mc25",
+#' #   fitTPU = TRUE,
+#' #   Ea_gamma_star = 0,
+#' #   Ea_g_mc = 0,
+#' #   values1 = seq(
+#' #     from = 20,
+#' #     to = 40,
+#' #     by = 2
+#' #   ),
+#' #   values2 = seq(
+#' #     from = 0.5,
+#' #     to = 2,
+#' #     by = 0.1
+#' #   )
+#' # )
+#'
+#' # Graph V_cmax
+#' # ggplot(pars, aes(x = gamma_star25, y = g_mc25, z = V_cmax)) +
+#' #   geom_tile(aes(fill = V_cmax)) +
+#' #   labs(
+#' #     x = expression(Gamma * "*"[25] ~ "(" * mu * mol ~ mol^
+#' #       {
+#' #         -1
+#' #       } * ")"),
+#' #     y = expression(g[m][25] ~ "(" * mu * mol ~ m^{
+#' #       -2
+#' #     } ~ s^{
+#' #       -1
+#' #     } ~ Pa^
+#' #       {
+#' #         -1
+#' #       } * ")")
+#' #   ) +
+#' #   scale_fill_distiller(palette = "Greys") +
+#' #   geom_contour(colour = "Black", size = 1) +
+#' #   theme_bw()
+#' # }
+#'
+analyze_sensitivity <- function(data,
+                                funct,
+                                test1 = NA,
+                                values1,
+                                test2 = NA,
+                                values2,
+                                element_out = 1,
+                                ...) {
+  # Create an empty list for ACi fits
+  fits <- list(NULL)
+
+  # Next loops through values depending on whether there are
+  # two input parameters or one.
+  # Note that these loops generalize the arguments and functions
+  if (!is.na(test2)) {
+    # Start progress bar
+    pb <- txtProgressBar(min = 0, max = length(values2) *
+      length(values1), style = 3)
+    # Loop through values of test1 and test2
+    for (j in seq_len(length(values2))) {
+      for (i in seq_len(length(values1))) {
+        fits[[i + (j - 1) * length(values1)]] <- exec(funct,
+          data = data,
+          !!test1 := values1[i],
+          !!test2 := values2[j],
+          ...
+        )
+        # Set progress bar
+        setTxtProgressBar(pb, i + (j - 1) * length(values1))
+      }
+    }
+  } else {
+    # Start progress bar
+    pb <- txtProgressBar(min = 0, max = length(values1), style = 3)
+    for (i in seq_len(length(values1))) {
+      fits[[i]] <- exec(funct,
+        data = data,
+        !!test1 := values1[i],
+        ...
+      )
+      # Set progress bar
+      setTxtProgressBar(pb, i)
+    }
+  }
+  # Create empty list for parameter outputs
+  pars <- vector("list", length(fits))
+
+  # Compile parameter outputs
+  # Main challenge here when using out-of-package functions:
+  # Output style may vary, making this component behave
+  # unexpectedly
+  for (i in seq_along(fits)) {
+    pars[[i]] <- fits[[i]][[element_out]]
+  }
+  # Convert parameter outputs to dataframe
+  pars <- do.call("bind_rows", pars)
+  # Return parameters as output
+  return(pars)
+}

data/R/aq_response.R

@@ -0,0 +1,32 @@
+#' Non-rectangular hyperbolic model of light responses
+#'
+#' @description 
+#' `r lifecycle::badge("deprecated")`
+#' 
+#' Please use `marshall_biscoe_1980()`.
+#' 
+#' @param k_sat Light saturated rate of process k
+#' @param phi_J Quantum efficiency of process k
+#' @param Q_abs Absorbed light intensity (umol m-2 s-1)
+#' @param theta_J Curvature of the light response
+#'
+#' @return aq_response is used to describe the response of a process to
+#' absorbed light intensity. Assumes that input is absorbed light. Note
+#' that if absorbed light is not used, then the meaning of phi_J becomes
+#' unclear. This function is designed to be used with fit_aq_response,
+#' however it could easily be fed into a different fitting approach (e.g.
+#' Bayesian approaches). Originally from Marshall et al. 1980.
+#'
+#' @references
+#' Marshall B, Biscoe P. 1980. A model for C3 leaves describing the
+#' dependence of net photosynthesis on irradiance. J Ex Bot 31:29-39
+#' @export
+aq_response = function(k_sat, phi_J, Q_abs, theta_J) {
+  
+  lifecycle::deprecate_warn("2.1.1", "aq_response()", "marshall_biscoe_1980()", always = FALSE)
+  
+  k_net = ((k_sat + phi_J * Q_abs) -
+    sqrt((k_sat + phi_J * Q_abs)^2 -
+      4 * k_sat * phi_J * Q_abs * theta_J)) /
+    (2 * theta_J)
+}

data/R/bake-par.R

@@ -0,0 +1,39 @@
+#' S3 class bake_par
+#
+
+#' @param .x A list to be constructed into **bake_par**.
+#'
+#' @returns
+#'
+#' Constructor function for bake_par class. This function ensures that leaf
+#' temperature gets properly "baked" into leaf parameters.
+#'
+#' @export
+
+bake_par = function(.x) {
+  
+  which = "bake"
+  
+  # Check parameters names ----
+  nms = check_parameter_names(.x, which = which, use_tealeaves = FALSE)
+  .x = .x[nms]
+  
+  # Set units ----
+  .x = .x |>
+    set_parameter_units(
+      .data$type == which, 
+      !.data$temperature_response,
+      !.data$tealeaves
+    )
+  
+  # Assert bounds on values ----
+  .x |>
+    assert_parameter_bounds(
+      .data$type == which, 
+      !.data$temperature_response,
+      !.data$tealeaves
+    )
+  
+  structure(.x, class = c(stringr::str_c(which, "_par"), "list"))
+  
+}

data/R/bake.R

@@ -0,0 +1,235 @@
+#' S3 class baked
+#' @name baked-class
+#' @description See [bake()]
+
+NULL
+
+#' Leaf parameter temperature responses
+#'
+#' @description 'bake' leaf parameters using temperature response functions
+#'
+#' @name bake
+#'
+#' @inheritParams photosynthesis
+#' @inheritParams A_supply
+#' 
+#' @returns 
+#'
+#' Constructor function for `baked` class. This will also inherit class
+#' [leaf_par()] and [list()]. This function ensures that 
+#' temperature is "baked in" to leaf parameter calculations `T_leaf` using 
+#' temperature response functions detailed below.
+#'
+#' @details
+#'
+#' Several leaf parameters ([leaf_par()]) are temperature sensitive.
+#' Temperature-sensitive parameters are input at a reference temperature of 
+#' 25 °C. These parameters are provided as `par_name25` and then "baked"
+#' using the appropriate temperature response function and parameters in
+#' [bake_par()]. The "baked" parameter will have the name without "25"
+#' appended (`par_name`). E.g. `V_cmax25` becomes `V_cmax`. \cr
+#' \cr
+#' Temperature response functions following Buckley and  Diaz-Espejo (2015) \cr
+#' \cr
+#' Temperature response function 1 (`temp_response1`): \cr
+#'
+#' \deqn{\mathrm{par}(T_\mathrm{leaf}) = \mathrm{par25}~\mathrm{exp}(E_\mathrm{a} / (R T_\mathrm{ref}) (T_\mathrm{leaf} - 25) / (T_\mathrm{leaf} + 273.15))}{par(T_leaf) = par25 exp(E_a / (R T_ref) (T_leaf - 25) / (T_leaf + 273.15))}
+#'
+#' \eqn{T_\mathrm{ref}}{T_ref} is the reference temperature in K \cr
+#' \eqn{T_\mathrm{leaf}}{T_leaf} is the leaf temperature in °C \cr
+#' \cr
+#' Temperature response function 2 (`temp_response2`) is the above equation multiplied by: \cr
+#'
+#' \deqn{(1 + \mathrm{exp}((D_\mathrm{s} / R - E_\mathrm{d} / (R T_\mathrm{ref})))) / (1 + \mathrm{exp}((D_\mathrm{s} / R) - (E_\mathrm{d} / (R (T_\mathrm{leaf} + 273.15)))))}{(1 + exp((D_s / R - E_d / (R T_ref)))) / (1 + exp((D_s / R) - (E_d / (R (T_leaf + 273.15)))))}
+#'
+#' Function 1 increases exponentially with temperature; Function 2 peaks a particular temperature.
+#'
+#' @encoding UTF-8
+#'
+#' @references
+#'
+#' Buckley TN, Diaz-Espejo A. 2015. Partitioning changes in photosynthetic rate 
+#' into contributions from different variables. Plant, Cell and Environment 38:
+#' 1200-1211.
+#'
+#' @examples
+#' bake_par = make_bakepar()
+#' constants = make_constants(use_tealeaves = FALSE)
+#' enviro_par = make_enviropar(use_tealeaves = FALSE)
+#' leaf_par = make_leafpar(
+#'   replace = list(T_leaf = set_units(293.15, K)),
+#'   use_tealeaves = FALSE
+#' )
+#' baked_leafpar = bake(leaf_par, enviro_par, bake_par, constants)
+#'
+#' baked_leafpar$V_cmax25
+#' baked_leafpar$V_cmax
+#' @encoding UTF-8
+#'
+#' @export
+
+bake = function(
+    leaf_par, 
+    enviro_par, 
+    bake_par, 
+    constants, 
+    assert_units = TRUE
+  ) {
+  
+  # Assert units before baking ----
+  if (assert_units) {
+    leaf_par %<>% leaf_par(use_tealeaves = FALSE)
+    enviro_par %<>% enviro_par(use_tealeaves = FALSE)
+    bake_par %<>% bake_par()
+    constants %<>% constants(use_tealeaves = FALSE)
+  }
+
+  # Remove units prior to baking ----
+  pars = c(leaf_par, enviro_par, bake_par, constants) |>
+    purrr::map_if(~ inherits(.x, "units"), drop_units)
+  T_ref = 298.15
+  
+  # Calculate parameters at T_leaf based on temperature response function ----
+  # Assumes that g_liqc has same temperature response function as g_mc
+  if (length(pars$g_liqc25) != 0) {
+    leaf_par$g_liqc = temp_resp2(
+      pars$g_liqc25, pars$Ds_gmc, pars$Ea_gmc, pars$Ed_gmc, pars$R, pars$T_leaf, 
+      T_ref, unitless = TRUE
+    )
+  }
+  
+  if (length(leaf_par$delta_ias_lower) != 0 & length(leaf_par$delta_ias_upper) != 0) {
+    D_c = .get_Dx(pars$D_c0, pars$T_leaf, pars$eT, pars$P, unitless = TRUE)
+    leaf_par$g_iasc_lower = 1e9 * D_c / pars$delta_ias_lower * 
+      pars$P / (pars$R * pars$T_leaf)
+    leaf_par$g_iasc_upper = 1e9 * D_c / pars$delta_ias_upper * 
+      pars$P / (pars$R * pars$T_leaf)
+  }
+  
+  if (length(pars$g_mc25) != 0) {
+    leaf_par$g_mc = temp_resp2(
+      pars$g_mc25, pars$Ds_gmc, pars$Ea_gmc, pars$Ed_gmc, pars$R, pars$T_leaf, 
+      T_ref, unitless = TRUE
+    )
+  }
+  
+  leaf_par$gamma_star = temp_resp1(pars$gamma_star25, pars$Ea_gammastar,
+    pars$R, pars$T_leaf, T_ref,
+    unitless = TRUE
+  )
+  leaf_par$J_max = temp_resp2(pars$J_max25, pars$Ds_Jmax, pars$Ea_Jmax,
+    pars$Ed_Jmax, pars$R, pars$T_leaf, T_ref,
+    unitless = TRUE
+  )
+  leaf_par$K_C = temp_resp1(pars$K_C25, pars$Ea_KC, pars$R, pars$T_leaf,
+    T_ref,
+    unitless = TRUE
+  )
+  leaf_par$K_O = temp_resp1(pars$K_O25, pars$Ea_KO, pars$R, pars$T_leaf,
+    T_ref,
+    unitless = TRUE
+  )
+  leaf_par$R_d = temp_resp1(pars$R_d25, pars$Ea_Rd, pars$R, pars$T_leaf,
+    T_ref,
+    unitless = TRUE
+  )
+  leaf_par$V_cmax = temp_resp1(pars$V_cmax25, pars$Ea_Vcmax, pars$R,
+    pars$T_leaf, T_ref,
+    unitless = TRUE
+  )
+  leaf_par$V_tpu = temp_resp1(pars$V_tpu25, pars$Ea_Vtpu, pars$R, pars$T_leaf,
+    T_ref,
+    unitless = TRUE
+  )
+  
+  # Set units ----
+  leaf_par = set_parameter_units(leaf_par, .data$R %in% names(leaf_par))
+
+  # Assert bounds on values ----
+  # If !assert_units, no assertion is performed
+  if (assert_units) {
+    leaf_par |>
+      assert_parameter_bounds(
+        .data$type == "leaf", 
+        .data$temperature_response,
+        !.data$tealeaves
+      )
+  }
+  
+  leaf_par %<>% structure(class = c("baked", "leaf_par", "list"))
+
+  leaf_par
+}
+
+#' Temperature response function 1
+#'
+#' @rdname bake
+#'
+#' @param par25 Parameter value at 25 °C of class `units`.
+#' @param E_a Empirical temperature response value in J/mol of class
+#' `units`.
+#' @param R Ideal gas constant in J / (mol K) of class `units`. See
+#' [make_constants()].
+#' @param T_leaf Leaf temperature in K of class `units`. Will be converted
+#' to °C.
+#' @param T_ref Reference temperature in K of class `units`.
+#'
+#' @export
+
+temp_resp1 = function(par25, E_a, R, T_leaf, T_ref, unitless) {
+  if (unitless) {
+    T_leaf %<>% magrittr::subtract(273.15)
+  } else {
+    pars_unit = units(par25)
+    par25 %<>% drop_units()
+
+    E_a %<>% set_units(J / mol) %>% drop_units()
+    R %<>% set_units(J / K / mol) %>% drop_units()
+    T_leaf %<>% set_units(degreeC) %>% drop_units()
+    T_ref %<>% set_units(K) %>% drop_units()
+  }
+
+  a1 = exp(E_a / (R * T_ref) * ((T_leaf - 25) / (T_leaf + 273.15)))
+
+  ret = par25 * a1
+  if (!unitless) units(ret) = pars_unit
+  ret
+}
+
+#' Temperature response function 2
+#'
+#' @rdname bake
+#'
+#' @inheritParams temp_resp1
+#' @param D_s Empirical temperature response value in J / (mol K) of class
+#' `units`.
+#' @param E_d Empirical temperature response value in J/mol of class
+#' `units`.
+#'
+#' @export
+
+temp_resp2 = function(par25, D_s, E_a, E_d, R, T_leaf, T_ref, unitless) {
+  a1 = temp_resp1(par25, E_a, R, T_leaf, T_ref, unitless)
+
+  if (unitless) {
+    T_leaf %<>% magrittr::subtract(273.15)
+  } else {
+    pars_unit = units(par25)
+    par25 %<>% drop_units()
+    a1 %<>% drop_units()
+
+    D_s %<>% set_units(J / mol / K) %>% drop_units()
+    E_a %<>% set_units(J / mol) %>% drop_units()
+    E_d %<>% set_units(J / mol) %>% drop_units()
+    R %<>% set_units(J / K / mol) %>% drop_units()
+    T_leaf %<>% set_units(degreeC) %>% drop_units()
+    T_ref %<>% set_units(K) %>% drop_units()
+  }
+
+  a2 = (1 + exp((D_s / R - E_d / (R * T_ref)))) /
+    (1 + exp((D_s / R) - (E_d / (R * (T_leaf + 273.15)))))
+
+  ret = a1 * a2
+  if (!unitless) units(ret) = pars_unit
+  ret
+}

data/R/calculated-parameters.R

@@ -0,0 +1,58 @@
+#' Get default functions for calculated parameters in [photosynthesis]
+#' 
+#' @name calculated-parameters
+#' @param .f_name character string of function
+#' @encoding UTF-8
+get_f_parameter = function(.f_name) {
+  
+  .f_name |>
+    match.arg(c("f_nu", "f_sh", "T_sky")) |>
+    switch(
+      
+      f_nu = function(Re, type, T_air, T_leaf, surface, unitless) {
+        if (!unitless) {
+          stopifnot(units(T_air)$numerator == "K" &
+                      length(units(T_air)$denominator) == 0L)
+          stopifnot(units(T_leaf)$numerator == "K" &
+                      length(units(T_leaf)$denominator) == 0L)
+        }
+        
+        type %<>% match.arg(c("free", "forced"))
+        
+        if (identical(type, "forced")) {
+          if (unitless) {
+            if (Re <= 4000) ret = list(a = 0.6, b = 0.5)
+            if (Re > 4000) ret = list(a = 0.032, b = 0.8)
+          } else {
+            if (Re <= set_units(4000)) ret = list(a = 0.6, b = 0.5)
+            if (Re > set_units(4000)) ret = list(a = 0.032, b = 0.8)
+          }
+          return(ret)
+        }
+        
+        if (identical(type, "free")) {
+          surface %<>% match.arg(c("lower", "upper"))
+          if ((surface == "upper" & T_leaf > T_air) |
+              (surface == "lower" & T_leaf < T_air)) {
+            ret = list(a = 0.5, b = 0.25)
+          } else {
+            ret = list(a = 0.23, b = 0.25)
+          }
+          return(ret)
+        }
+      },
+      
+      f_sh = function(type, unitless) {
+        type |>
+          match.arg(c("free", "forced")) |>
+          switch(forced = 0.33, free = 0.25)
+      },
+      
+      T_sky = function(pars) {
+        set_units(pars$T_air, K) - set_units(20, K) * 
+          set_units(pars$S_sw, W / m^2) / set_units(1000, W / m^2)
+      }
+      
+    )
+  
+}

data/R/compile_data.R

@@ -0,0 +1,84 @@
+#' Compiling outputs from lists
+#'
+#' @param data List of elements
+#' @param output_type Type of desired output. For graphs or models, use "list",
+#' for parameters, use "dataframe".
+#' @param list_element Which elements of the sublists do you wish to compile?
+#'
+#' @return compile_data converts the outputs of fit_many into a form more
+#' readily usable for analysis. Can be used to create dataframe of all
+#' fitted parameters, a list of model outputs, a list of graphs for plotting.
+#' This function is NOT restricted to compiling outputs from plantecophystools
+#' but could be used to compile elements from ANY list of lists.
+#'
+#' @export
+#'
+#' @examples
+#' \donttest{
+#' # Read in your data
+#' # Note that this data is coming from data supplied by the package
+#' # hence the complicated argument in read.csv()
+#' # This dataset is a CO2 by light response curve for a single sunflower
+#' data <- read.csv(system.file("extdata", "A_Ci_Q_data_1.csv",
+#'   package = "photosynthesis"
+#' ))
+#'
+#' # Define a grouping factor based on light intensity to split the ACi
+#' # curves
+#' data$Q_2 <- as.factor((round(data$Qin, digits = 0)))
+#'
+#' # Convert leaf temperature to K
+#' data$T_leaf <- data$Tleaf + 273.15
+#'
+#' # Fit many curves
+#' fits <- fit_many(
+#'   data = data,
+#'   varnames = list(
+#'     A_net = "A",
+#'     T_leaf = "T_leaf",
+#'     C_i = "Ci",
+#'     PPFD = "Qin"
+#'   ),
+#'   funct = fit_aci_response,
+#'   group = "Q_2"
+#' )
+#'
+#' # Compile graphs into a list for plotting
+#' fits_graphs <- compile_data(fits,
+#'   list_element = 2
+#' )
+#'
+#' # Plot one graph from the compiled list
+#' plot(fits_graphs[[1]])
+#' }
+compile_data <- function(
+    data,
+    output_type = "list",
+    list_element
+  ) {
+  # Is output_type compatible with options?
+  if (!output_type %in% c("list", "dataframe")) {
+    stop("Output type not found. Use list or dataframe.")
+  }
+  # Create empty list
+  output <- vector("list", length(data))
+  # Create output list with desired elements
+  # Add correct names
+  for (i in seq_along(data)) {
+    output[[i]] <- data[[i]][[list_element]]
+    names(output)[i] <- names(data[i])
+  }
+  # If desired output is a list, return output list here
+  if (output_type == "list") {
+    return(output)
+  }
+  # If desired output is a dataframe, create it from the list here
+  # Add ID column to dataframe
+  if (output_type == "dataframe") {
+    for (i in 1:length(output)) {
+      output[[i]]$ID <- names(output)[i]
+    }
+    output <- do.call("bind_rows", output)
+    return(output)
+  }
+}

data/R/compute_sensitivity.R

@@ -0,0 +1,172 @@
+#' Computing measures of sensitivity
+#'
+#' @param data Dataframe with output from sensitivity_analysis()
+#' @param varnames Variable names
+#' @param test1_ref Reference value for parameter
+#' @param test2_ref Reference value for parameter
+#'
+#' @return compute_sensitivity calculates two sets of sensitivity measures:
+#' parameter effect (Bauerle et al., 2014), and control coefficient (Capaldo &
+#' Pandis, 1997). This function is useful in determining how much a given
+#' input (assumed or otherwise) can affect the model output and conclusions.
+#' Particularly useful if a given parameter is unknown during a fitting or
+#' modeling process.
+#'
+#' @references
+#' Bauerle WL, Daniels AB, Barnard DM. 2014. Carbon and water flux responses to
+#' physiology by environment interactions: a sensitivity analysis of variation
+#' in climate on photosynthetic and stomatal parameters. Climate Dynamics 42:
+#' 2539-2554.
+#'
+#' Capaldo KP, Pandis SN 1997. Dimethylsulfide chemistry in the remote marine
+#' atmosphere: evaluation and sensitivity analysis of available mechanisms.
+#' J Geophys Res 102:23251-23267
+#' @importFrom utils setTxtProgressBar
+#' @importFrom utils txtProgressBar
+#' @export
+#'
+#' @examples
+#' \donttest{
+#' # Read in your data
+#' # Note that this data is coming from data supplied by the package
+#' # hence the complicated argument in read.csv()
+#' # This dataset is a CO2 by light response curve for a single sunflower
+#' data <- read.csv(system.file("extdata", "A_Ci_Q_data_1.csv",
+#'   package = "photosynthesis"
+#' ))
+#'
+#' # Define a grouping factor based on light intensity to split the ACi
+#' # curves
+#' data$Q_2 <- as.factor((round(data$Qin, digits = 0)))
+#'
+#' # Convert leaf temperature to K
+#' data$T_leaf <- data$Tleaf + 273.15
+#'
+#' # Run a sensitivity analysis on gamma_star and mesophyll conductance
+#' # at 25 Celsius for one individual curve
+#' # pars <- analyze_sensitivity(
+#' #   data = data[data$Q_2 == 1500, ],
+#' #   funct = fit_aci_response,
+#' #   varnames = list(
+#' #     A_net = "A",
+#' #     T_leaf = "T_leaf",
+#' #     C_i = "Ci",
+#' #     PPFD = "Qin"
+#' #   ),
+#' #   useg_mct = TRUE,
+#' #   test1 = "gamma_star25",
+#' #   element_out = 1,
+#' #   test2 = "g_mc25",
+#' #   fitTPU = TRUE,
+#' #   Ea_gamma_star = 0,
+#' #   Ea_g_mc = 0,
+#' #   values1 = seq(
+#' #     from = 20,
+#' #     to = 60,
+#' #     by = 2
+#' #   ),
+#' #   values2 = seq(
+#' #     from = 0.2,
+#' #     to = 2,
+#' #     by = 0.1
+#' #   )
+#' # )
+#' # Compute measures of sensitivity
+#' # par2 <- compute_sensitivity(
+#' #   data = pars,
+#' #   varnames = list(
+#' #     Par = "V_cmax",
+#' #     test1 = "gamma_star25",
+#' #     test2 = "g_mc25"
+#' #   ),
+#' #   test1_ref = 42,
+#' #   test2_ref = 1
+#' # )
+#' # # Plot control coefficients
+#' # ggplot(par2, aes(y = CE_gamma_star25, x = CE_g_mc25, colour = V_cmax)) +
+#' #   geom_point() +
+#' #   theme_bw()
+#' # # Note that in this case a missing point appears due to an infinity
+#' }
+compute_sensitivity <- function(data,
+                                varnames = list(
+                                  Par = "Par",
+                                  test1 = "test1",
+                                  test2 = "test2"
+                                ),
+                                test1_ref,
+                                test2_ref) {
+  # Set variable names
+  data$Par <- data[, varnames$Par]
+  data$test1 <- data[, varnames$test1]
+  data$test2 <- data[, varnames$test2]
+  # Calculate parameter effect (PE) of one input per each instance of
+  # the other input. Therefore need to split data relative to one variable,
+  # calculate PE, merge data, then split by other variable and repeat
+  # Split data by variable 2
+  data <- split(data, data$test2)
+  # Start progress bar
+  pb <- txtProgressBar(min = 0, max = length(data), style = 3)
+  # Calculate parameter effect
+  for (i in 1:length(data)) {
+    data[[i]]$PE_test1 <- abs(data[[i]][data[[i]]$test1 ==
+      max(data[[i]]$test1), ]$Par -
+      data[[i]][data[[i]]$test1 ==
+        min(data[[i]]$test1), ]$Par) /
+      mean(data[[i]]$Par) * 100
+    # Set progress bar
+    setTxtProgressBar(pb, i)
+  }
+  # Bind back to dataframe
+  data <- do.call("rbind", data)
+  # Split data by variable 1
+  data <- split(data, data$test1)
+  # Start progress bar
+  pb <- txtProgressBar(min = 0, max = length(data), style = 3)
+  # Calculate parameter effect
+  for (i in 1:length(data)) {
+    data[[i]]$PE_test2 <- abs(data[[i]][data[[i]]$test2 ==
+      max(data[[i]]$test2), ]$Par -
+      data[[i]][data[[i]]$test2 ==
+        min(data[[i]]$test2), ]$Par) /
+      mean(data[[i]]$Par) * 100
+    # Set progress bar
+    setTxtProgressBar(pb, i)
+  }
+  # Bind back to dataframe
+  data <- do.call("rbind", data)
+
+  # Calculate control coefficients. In this case, we are deriving it numerically
+  # Need reference point in the entire parameter space, this is test1_ref and
+  # test2_ref. Calculations from Capaldo & Pandis 1997.
+  data$CE_test1 <- NA
+  data$CE_test2 <- NA
+  for (i in 1:nrow(data)) {
+    data$CE_test1[i] <- (log(data$Par[i]) - log(data[data$test1 == test1_ref &
+      data$test2 == test2_ref, ]$Par)) /
+      (log(data$test1[i]) - log(data[data$test1 == test1_ref &
+        data$test2 == test2_ref, ]$test1))
+    data$CE_test2[i] <- (log(data$Par[i]) - log(data[data$test1 == test1_ref &
+      data$test2 == test2_ref, ]$Par)) /
+      (log(data$test2[i]) - log(data[data$test1 == test1_ref &
+        data$test2 == test2_ref, ]$test2))
+  }
+
+  # Name output columns based on selected variable name
+  for (i in 1:ncol(data)) {
+    if (colnames(data)[i] == "PE_test1") {
+      colnames(data)[i] <- paste0("PE_", varnames$test1)
+    }
+    if (colnames(data)[i] == "PE_test2") {
+      colnames(data)[i] <- paste0("PE_", varnames$test2)
+    }
+    if (colnames(data)[i] == "CE_test1") {
+      colnames(data)[i] <- paste0("CE_", varnames$test1)
+    }
+    if (colnames(data)[i] == "CE_test2") {
+      colnames(data)[i] <- paste0("CE_", varnames$test2)
+    }
+  }
+  # Return dataframe
+  return(data)
+}

data/R/conductance.R

@@ -0,0 +1,307 @@
+#' Conductance to CO2 (mol / m^2 / s)
+#'
+#' @inheritParams A_supply
+#'
+#' @name CO2_conductance
+#'
+#' @details
+#' 
+#' **Default conductance model**
+#' 
+#' The conductance model described in this section is used by default unless
+#' additional anatomical parameters described in the next section are provided.
+#' 
+#' Total conductance to CO2 is the sum of parallel conductances on the lower
+#' (\eqn{g_\mathrm{c,lower}}{gc_lower}) and upper
+#' (\eqn{g_\mathrm{c,upper}}{gc_upper}) leaf portions:
+#'
+#'  \deqn{g_\mathrm{c,total} = g_\mathrm{c,lower} + g_\mathrm{c,upper}}{gc_total = gc_lower + gc_upper}
+#'
+#' Each partial conductance consists of two parallel conductances, the
+#' cuticular conductance (\eqn{g_\mathrm{u,c}}{g_uc}) and the in-series
+#' conductances through mesophyll (\eqn{g_\mathrm{m,c}}{g_mc}), stomata (\eqn{g_\mathrm{s,c}}{g_sc}), and boundary layer (\eqn{g_\mathrm{b,c}}{g_bc}). To simplify the formula, I use substitute resistance where \eqn{r_x = 1 / g_x}. For surface \eqn{i}:
+#'
+#' \deqn{g_{\mathrm{c},i} = g_{\mathrm{u},i} + (1 / (r_{\mathrm{m},i} + r_{\mathrm{s},i} + r_{\mathrm{b},i}))}{g_ci = g_ui + (1 / (r_mi + r_si + r_bi))}
+#'
+#' The cuticular, stomatal, and mesophyll conductances can be the same or
+#' different for upper and lower. The partitioning factors (\eqn{k_x}) divide the conductance between surfaces while keeping the total conductance constant:
+#'
+#' \deqn{g_{x,\mathrm{lower}} = g_x (1 / (1 + k_x))}{gx_lower = g_x (1 / (1 + k_x))}
+#' \deqn{g_{x,\mathrm{upper}} = g_x (k_x / (1 + k_x))}{gx_upper = g_x (k_x / (1 + k_x))}
+#' \deqn{g_x = g_{x,\mathrm{lower}} + g_{x,\mathrm{upper}}}{g_x = gx_lower + gx_upper}
+#'
+#' How the partitioning factors work: \cr
+#' \tabular{ll}{
+#' \eqn{k_x} \tab description \cr
+#' 0 \tab all conductance on **lower** surface/portion \cr
+#' 0.5 \tab 2/3 conductance on **lower** surface \cr
+#' 1 \tab conductance evenly divided between surfaces/portions \cr
+#' 2 \tab 2/3 conductance on **upper** surface \cr
+#' Inf \tab all conductance on **upper** surface/portion
+#' }
+#'
+#' The boundary layer conductances for each are calculated on the basis of mass 
+#' and heat transfer (see [.get_gbc()]).
+#'
+#' \tabular{lllll}{
+#' *Symbol* \tab *R* \tab *Description* \tab *Units* \tab *Default*\cr
+#' \eqn{g_\mathrm{mc}}{g_mc} \tab `g_mc` \tab mesophyll conductance to CO2 (T_leaf) \tab mol / m\eqn{^2} / s \tab [calculated][bake] \cr
+#' \eqn{g_\mathrm{sc}}{g_sc} \tab `g_sc` \tab stomatal conductance to CO2 \tab mol / m\eqn{^2} / s \tab `r dplyr::pull(photo_parameters[photo_parameters$R == "g_sc","default"])` \cr
+#' \eqn{g_\mathrm{uc}}{g_uc} \tab `g_uc` \tab cuticular conductance to CO2 \tab mol / m\eqn{^2} / s \tab `r dplyr::pull(photo_parameters[photo_parameters$R == "g_uc","default"])` \cr
+#' \eqn{k_\mathrm{mc}}{k_mc} \tab `k_mc` \tab partition of \eqn{g_\mathrm{mc}}{g_mc} to lower mesophyll \tab none \tab `r dplyr::pull(photo_parameters[photo_parameters$R == "k_mc","default"])` \cr
+#' \eqn{k_\mathrm{sc}}{k_sc} \tab `k_sc` \tab partition of \eqn{g_\mathrm{sc}}{g_sc} to lower surface \tab none \tab `r dplyr::pull(photo_parameters[photo_parameters$R == "k_sc","default"])` \cr
+#' \eqn{k_\mathrm{uc}}{k_uc} \tab `k_uc` \tab partition of \eqn{g_\mathrm{uc}}{g_uc} to lower surface \tab none \tab `r dplyr::pull(photo_parameters[photo_parameters$R == "k_uc","default"])` \cr
+#' }
+#'
+#' **New conductance model**
+#' 
+#' The conductance model described in this section is implemented in 
+#' **photosynthesis** (>= 2.1.0) if parameters to calculate the internal 
+#' airspace and liquid-phase conductances (`A_mes_A`, `g_liqc`) are 
+#' provided. These parameters are 1) the effective path lengths through the 
+#' lower and upper leaf internal airspaces (`delta_ias_lower`, 
+#' `delta_ias_upper`) and 2) the mesophyll area per leaf area 
+#' (`A_mes_A`) and liquid-phase conductance per mesophyll cell area 
+#' (`g_liqc`).
+#' 
+#' Two parallel diffusion pathways, one from each leaf surface, converge to a 
+#' single CO2 concentration at the mesophyll cell boundary. We use a single 
+#' liquid-phase resistance to represent the combined cell wall, plasmalemma, and 
+#' chloroplast resistances. The gas-phase resistance through boundary layer, 
+#' cuticle/stomata, and internal airspace is \eqn{r_\mathrm{gas,c}}; the 
+#' liquid-phase intracellular resistance is \eqn{r_\mathrm{i,c}}.
+#' 
+#'  \deqn{r_\mathrm{total,c} = r_\mathrm{gas,c} + r_\mathrm{i,c}}{r_total,c = r_gas,c + r_i,c}
+#'  
+#' The gas-phase resistance occurs through two parallel pathways, which we refer 
+#' to as the 'lower' and 'upper' pathways because horizontally oriented leaves 
+#' often have different anatomical properties on each surface. The gas-phase 
+#' resistance through pathway \eqn{i \in \{\textrm{lower,upper\}}} is:
+#' 
+#' \deqn{r_{\mathrm{gas,c},i} = r_{\mathrm{b,c},i} + r_{\mathrm{u+s,c},i} + r_{\mathrm{ias,c},i}}{r_gas,c,i = r_b,c,i + r_u+s,c,i + r_ias,c,i}
+#' 
+#' The subscripts \eqn{_\mathrm{b}}, \eqn{_\mathrm{u+s}}, and \eqn{_\mathrm{ias}} 
+#' denote boundary layer, cuticular + stomatal, and internal airspace, 
+#' respectively. The subscript \eqn{_\mathrm{c}} indicates we are considering 
+#' the conductance to CO2 rather than another molecular species.
+#' 
+#' Cuticular and stomatal conductances (1 / resistance) are parallel, so:
+#' 
+#' \deqn{1 / r_{\mathrm{u+s,c},i} = g_{\mathrm{u+s,c},i} = g_{\mathrm{u,c},i} + g_{\mathrm{s,c},i}}{1 / r_u+s,c,i = g_u+s,c,i = g_u,c,i + g_s,c,i}
+#' 
+#' Substituting the above expression into the equation for \eqn{r_{\mathrm{gas,c},i}}{r_gas,c,i}:
+#' 
+#' \deqn{r_{\mathrm{gas,c},i} = r_{\mathrm{b,c},i} + 1 / (g_{\mathrm{u,c},i} = g_{\mathrm{s,c},i}) + r_{\mathrm{ias,c},i}}{r_gas,c,i = r_b,c,i + 1 / (g_u,c,i + g_s,c,i) + r_ias,c,i}
+#' 
+#' The total gas-phase resistance is the inverse of the sum of the parallel 
+#' lower and upper conductances:
+#' 
+#' \deqn{1 / r_{\mathrm{gas,c}} = g_\mathrm{gas,c,lower} + g_\mathrm{gas,c,upper}}{1 / r_gas,c = g_gas,c = g_gas,c,lower + g_gas,c,upper}
+#' 
+#' The cuticular, stomatal, and mesophyll conductances can be the same or
+#' different for upper and lower. The partitioning factors \eqn{k_u} and \eqn{k_s} 
+#' divide the total cuticular and stomatal conductances, respectively, between 
+#' surfaces while keeping the total conductance constant:
+#'
+#' \deqn{g_{x,\mathrm{lower}} = g_x (1 / (1 + k_x))}{gx_lower = g_x (1 / (1 + k_x))}
+#' \deqn{g_{x,\mathrm{upper}} = g_x (k_x / (1 + k_x))}{gx_upper = g_x (k_x / (1 + k_x))}
+#' \deqn{g_x = g_{x,\mathrm{lower}} + g_{x,\mathrm{upper}}}{g_x = gx_lower + gx_upper}
+#'
+#' How the partitioning factors work: \cr
+#' \tabular{ll}{
+#' \eqn{k_x} \tab description \cr
+#' 0 \tab all conductance on **lower** surface/portion \cr
+#' 0.5 \tab 2/3 conductance on **lower** surface \cr
+#' 1 \tab conductance evenly divided between surfaces/portions \cr
+#' 2 \tab 2/3 conductance on **upper** surface \cr
+#' Inf \tab all conductance on **upper** surface/portion
+#' }
+#'
+#' The internal airspace conductance is the diffusivity of CO2 at a given
+#' temperature and pressure divided by the effective path length:
+#' 
+#' \deqn{g_\mathrm{ias,c,lower} = D_\mathrm{c} / \delta_\mathrm{ias,lower}}{g_iasc_lower = D_c / delta_ias_lower}
+#' \deqn{g_\mathrm{ias,c,upper} = D_\mathrm{c} / \delta_\mathrm{ias,upper}}{g_iasc_ipper = D_c / delta_ias_upper}
+#' 
+#' `g_iasc_lower` and `g_iasc_upper` are calculated in the [bake] 
+#' function. See [tealeaves::.get_Dx()] for calculating `D_c`.
+#' 
+#' The liquid-phase intracellular resistance is given by:
+#' 
+#' \deqn{1 / r_\mathrm{i,c} = g_\mathrm{i,c} = g_\mathrm{liq,c} A_\mathrm{mes} / A}{1 / r_i,c = g_i,c = g_liq,c A_mes / A}
+#' 
+#' \eqn{g_\mathrm{liq,c}}{g_liq,c} is temperature sensitive. See [bake()].
+#' 
+#' The boundary layer conductances for each are calculated on the basis of mass
+#' and heat transfer (see [.get_gbc()]).
+#' 
+#' @encoding UTF-8
+#' @md
+
+NULL
+
+#'  - g_tc: total conductance to CO2
+#'
+#' @rdname CO2_conductance
+.get_gtc = function(pars, unitless, use_legacy_version) {
+
+  if (check_new_conductance(pars, baked = TRUE)) {
+    
+    gbc_lower = .get_gbc(pars, "lower", unitless, use_legacy_version)
+    gsc_lower = .get_gsc(pars, "lower", unitless)
+    guc_lower = .get_guc(pars, "lower", unitless)
+    
+    gbc_upper = .get_gbc(pars, "upper", unitless, use_legacy_version)
+    gsc_upper = .get_gsc(pars, "upper", unitless)
+    guc_upper = .get_guc(pars, "upper", unitless)
+    
+    g_usc_lower = guc_lower + gsc_lower
+    g_usc_upper = guc_upper + gsc_upper
+    g_gasc_lower = 1 / (1 / gbc_lower + 1 / g_usc_lower + 1 / pars$g_iasc_lower)
+    g_gasc_upper = 1 / (1 / gbc_upper + 1 / g_usc_upper + 1 / pars$g_iasc_upper)
+    g_gasc = g_gasc_lower + g_gasc_upper
+    g_ic = pars$g_liqc * pars$A_mes_A
+    g_tc = 1 / (1 / g_gasc + 1 / g_ic)
+    
+    if (!unitless) g_tc %<>% set_units(mol / m^2 / s)
+    
+    return(g_tc)
+    
+  } else {
+    
+    gbc_lower = .get_gbc(pars, "lower", unitless, use_legacy_version)
+    gmc_lower = .get_gmc(pars, "lower", unitless)
+    gsc_lower = .get_gsc(pars, "lower", unitless)
+    guc_lower = .get_guc(pars, "lower", unitless)
+    
+    gbc_upper = .get_gbc(pars, "upper", unitless, use_legacy_version)
+    gmc_upper = .get_gmc(pars, "upper", unitless)
+    gsc_upper = .get_gsc(pars, "upper", unitless)
+    guc_upper = .get_guc(pars, "upper", unitless)
+    
+    rc_lower = 1 / gmc_lower + 1 / gsc_lower + 1 / gbc_lower
+    gc_lower = 1 / rc_lower
+    gc_lower %<>% magrittr::add(guc_lower)
+    rc_upper = 1 / gmc_upper + 1 / gsc_upper + 1 / gbc_upper
+    gc_upper = 1 / rc_upper
+    gc_upper %<>% magrittr::add(guc_upper)
+    
+    g_tc = gc_lower + gc_upper
+    
+    if (!unitless) g_tc %<>% set_units(mol / m^2 / s)
+    
+    return(g_tc)
+    
+  }
+  
+}
+
+#'  - g_uc: cuticular conductance to CO2
+#'
+#' @param surface Leaf surface (lower or upper)
+#'
+#' @rdname CO2_conductance
+.get_guc = function(pars, surface, unitless) {
+  surface %<>% match.arg(c("lower", "upper"))
+
+  if (unitless) {
+    g_uc = switch(
+      surface,
+      lower = pars$g_uc * (1 / (1 + pars$k_uc)),
+      upper = pars$g_uc * (pars$k_uc / (1 + pars$k_uc))
+    )
+  } else {
+    g_uc = switch(
+      surface,
+      lower = pars$g_uc * (set_units(1) / (set_units(1) + pars$k_uc)),
+      upper = pars$g_uc * (pars$k_uc / (set_units(1) + pars$k_uc))
+    )
+  }
+
+  g_uc
+}
+#'  - g_bc: boundary layer conductance to CO2
+#'
+#' @inheritParams .get_guc
+#'
+#' @rdname CO2_conductance
+.get_gbc = function(pars, surface, unitless, use_legacy_version) {
+  surface %<>% match.arg(c("lower", "upper"))
+
+  # Hack because f_sh = sh_constant, f_sh = sh_constant in tealeaves
+  # Should update tealeaves to harmonize variable and function names
+  pars$sh_constant = pars$f_sh
+  pars$nu_constant = pars$f_nu
+  ret = .get_gbw(pars$T_leaf, surface, pars, unitless) |>
+      set_units(m / s) |>
+      gunit::convert_conductance(
+        P = set_units(pars$P, kPa),
+        R = set_units(pars$R, J / K / mol),
+        Temp = set_units((pars$T_air + pars$T_leaf) / 2, K)
+      ) |>
+      dplyr::pull(.data$`umol/m^2/s/Pa`) |>
+      gunit::gw2gc(D_c = pars$D_c0, D_w = pars$D_w0, unitless = unitless,
+            a = ifelse(use_legacy_version, 1, 2/3)) |>
+    # Convert to mol / m^2 / s
+    magrittr::multiply_by(pars$P)
+  
+  # Divide 1e3 because conversion is from umol / kPa -> mol
+  # umol / m^2 / s / Pa * 1e3 Pa / kPa * mol / 1e6 umol
+  if (unitless) {
+    ret = ret / 1e3
+  } else {
+    ret = set_units(ret, mol/m^2/s)
+  }
+  
+  ret
+  
+}
+#'  - g_mc: mesophyll conductance to CO2
+#'
+#' @inheritParams .get_guc
+#'
+#' @rdname CO2_conductance
+.get_gmc = function(pars, surface, unitless) {
+  
+  surface %<>% match.arg(c("lower", "upper"))
+
+    if (unitless) {
+      g_mc = switch(
+        surface,
+        lower = pars$g_mc * (1 / (1 + pars$k_mc)),
+        upper = pars$g_mc * (pars$k_mc / (1 + pars$k_mc))
+      )
+    } else {
+      g_mc = switch(
+        surface,
+        lower = pars$g_mc * (1 / (set_units(1) + pars$k_mc)),
+        upper = pars$g_mc * (pars$k_mc / (set_units(1) + pars$k_mc))
+      )
+    }
+  
+  g_mc
+  
+}
+#'  - g_sc: stomatal conductance to CO2
+#'
+#' @inheritParams .get_guc
+#'
+#' @rdname CO2_conductance
+.get_gsc = function(pars, surface, unitless) {
+  surface %<>% match.arg(c("lower", "upper"))
+  if (unitless) {
+    g_sc = switch(
+      surface,
+      lower = pars$g_sc * (1 / (1 + pars$k_sc)),
+      upper = pars$g_sc * (pars$k_sc / (1 + pars$k_sc))
+    )
+  } else {
+    g_sc = switch(
+      surface,
+      lower = pars$g_sc * (set_units(1) / (set_units(1) + pars$k_sc)),
+      upper = pars$g_sc * (pars$k_sc / (set_units(1) + pars$k_sc))
+    )
+  }
+
+  g_sc
+}

data/R/constants.R

@@ -0,0 +1,35 @@
+#' S3 class constants
+#' @inheritParams photosynthesis
+#' @param .x A list to be constructed into **constants**.
+#'
+#' @returns
+#' Constructor function for constants class. This function ensures that
+#' physical constant inputs are properly formatted.
+#'
+#' @export
+constants = function(.x, use_tealeaves) {
+  
+  which = "constants"
+  
+  # Check parameters names ----
+  nms = check_parameter_names(.x, which = which, use_tealeaves = use_tealeaves)
+  .x = .x |> 
+    magrittr::extract(nms) |>
+    # Set units ----
+  set_parameter_units(
+    .data$type == which, 
+    !.data$temperature_response,
+    if (!use_tealeaves) {!.data$tealeaves} else TRUE
+  )
+  
+  # Assert bounds on values ----
+  .x |>
+    assert_parameter_bounds(
+      .data$type == which, 
+      !.data$temperature_response,
+      if (!use_tealeaves) {!.data$tealeaves} else TRUE
+    )
+  
+    structure(.x, class = c(which, "list"))
+    
+}

data/R/data.R

@@ -0,0 +1,14 @@
+#' Input parameters to simulate C3 photosynthesis using [photosynthesis()]
+#'
+#' A table of input parameters used in [photosynthesis()] 
+#'
+#' @format ## `photo_parameters`
+#' A data frame with `r nrow(photo_parameters)` rows and `r ncol(photo_parameters)`  columns:
+#' \describe{
+#'   \item{country}{Country name}
+#'   \item{iso2, iso3}{2 & 3 letter ISO country codes}
+#'   \item{year}{Year}
+#'   ...
+#' }
+#' @source <https://www.who.int/teams/global-tuberculosis-programme/data>
+"photo_parameters"

data/R/enviro-par.R

@@ -0,0 +1,65 @@
+#' S3 class enviro_par
+#
+
+#' @inheritParams photosynthesis
+#' @param .x A list to be constructed into **enviro_par**.
+#'
+#' @returns 
+#'
+#' Constructor function for enviro_par class. This function ensures that environmental parameter inputs are properly formatted.
+#'
+#' @export
+
+enviro_par = function(.x, use_tealeaves) {
+  
+  which = "enviro"
+  
+  # Check parameters names ----
+  nms = check_parameter_names(.x, which = which, use_tealeaves = use_tealeaves)
+  .x = .x |> 
+    magrittr::extract(nms) |>
+    # Set units ----
+  set_parameter_units(
+    .data$type == which, 
+    !.data$temperature_response,
+    if (!use_tealeaves) {!.data$tealeaves} else TRUE
+  )
+  
+  # Assert bounds on values ----
+  .x |>
+    assert_parameter_bounds(
+      .data$type == which, 
+      !.data$temperature_response,
+      if (!use_tealeaves) {!.data$tealeaves} else TRUE
+    )
+  
+  # Notify about T_sky ----
+  if (use_tealeaves) {
+
+    # T_sky can be set or provided as a function ----
+    if (is.null(.x$T_sky)) {
+      message(
+        '\nphotosynthesis (>= 1.0.2) will require users provide a T_sky value or
+        function to calculate T_sky from other parameters.
+        
+        For back-compatibility, if T_sky is not provided, this warning will
+        appear and the default function used in tealeaves (< 1.0.2) will be
+        applied.
+        
+        See more details in vignette("parameter-functions")
+        '
+      )
+
+      .x$T_sky = get_f_parameter("T_sky")
+      
+    } else {
+      stopifnot(is.function(.x$T_sky) | is.double(.x$T_sky))
+
+      if (is.double(.x$T_sky)) {
+        .x$T_sky %<>% set_units(K)
+      }
+    }
+  }
+
+  structure(.x, class = c(stringr::str_c(which, "_par"), "list"))
+}

data/R/fit_PV_curve.R

@@ -0,0 +1,263 @@
+#' Fitting pressure-volume curves
+#'
+#' @param data Dataframe
+#' @param varnames Variable names. varnames = list(psi = "psi", mass =
+#' "mass", leaf_mass = "leaf_mass", bag_mass = "bag_mass", leaf_area =
+#' "leaf_area") where psi is leaf water potential in MPa, mass is the
+#' weighed mass of the bag and leaf in g, leaf_mass is the mass of the
+#' leaf in g, bag_mass is the mass of the bag in g, and leaf_area is
+#' the area of the leaf in cm2.
+#' @param title Graph title
+#'
+#' @return fit_PV_curve fits pressure-volume curve data to determine:
+#' SWC: saturated water content per leaf mass (g H2O g leaf dry mass ^ -1),
+#' PI_o: osmotic potential at full turgor (MPa), psi_TLP: leaf water
+#' potential at turgor loss point (TLP) (MPa), RWC_TLP: relative water
+#' content at TLP (%), eps: modulus of elasticity at full turgor (MPa),
+#' C_FT: relative capacitance at full turgor (MPa ^ -1), C_TLP: relative
+#' capacitance at TLP (MPa ^ -1), and C_FTStar: absolute capacitance per
+#' leaf area (g m ^ -2 MPa ^ -1). Element 1 of the output list contains
+#' the fitted parameters, element 2 contains the water-psi graph, and
+#' element 3 contains the 1/psi-100-RWC graph.
+#'
+#' @references
+#' Koide RT, Robichaux RH, Morse SR, Smith CM. 2000. Plant water status,
+#' hydraulic resistance and capacitance. In: Plant Physiological Ecology:
+#' Field Methods and Instrumentation (eds RW Pearcy, JR Ehleringer, HA
+#' Mooney, PW Rundel), pp. 161-183. Kluwer, Dordrecht, the Netherlands
+#'
+#' Sack L, Cowan PD, Jaikumar N, Holbrook NM. 2003. The 'hydrology' of
+#' leaves: co-ordination of structure and function in temperate woody
+#' species. Plant, Cell and Environment, 26, 1343-1356
+#'
+#' Tyree MT, Hammel HT. 1972. Measurement of turgor pressure and water
+#' relations of plants by pressure bomb technique. Journal of Experimental
+#' Botany, 23, 267
+#'
+#' @importFrom ggplot2 geom_hline
+#' @export
+#'
+#' @examples
+#' \donttest{
+#' # Read in data
+#' data <- read.csv(system.file("extdata", "PV_curve.csv",
+#'   package = "photosynthesis"
+#' ))
+#'
+#' # Fit one PV curve
+#' fit <- fit_PV_curve(data[data$ID == "L2", ],
+#'   varnames = list(
+#'     psi = "psi",
+#'     mass = "mass",
+#'     leaf_mass = "leaf_mass",
+#'     bag_mass = "bag_mass",
+#'     leaf_area = "leaf_area"
+#'   )
+#' )
+#'
+#' # See fitted parameters
+#' fit[[1]]
+#'
+#' # Plot water mass graph
+#' fit[[2]]
+#'
+#' # Plot PV Curve
+#' fit[[3]]
+#'
+#' # Fit all PV curves in a file
+#' fits <- fit_many(data,
+#'   group = "ID",
+#'   funct = fit_PV_curve,
+#'   varnames = list(
+#'     psi = "psi",
+#'     mass = "mass",
+#'     leaf_mass = "leaf_mass",
+#'     bag_mass = "bag_mass",
+#'     leaf_area = "leaf_area"
+#'   )
+#' )
+#'
+#' # See parameters
+#' fits[[1]][[1]]
+#'
+#' # See water mass - water potential graph
+#' fits[[1]][[2]]
+#'
+#' # See PV curve
+#' fits[[1]][[3]]
+#'
+#' # Compile parameter outputs
+#' pars <- compile_data(
+#'   data = fits,
+#'   output_type = "dataframe",
+#'   list_element = 1
+#' )
+#'
+#' # Compile the water mass - water potential graphs
+#' graphs1 <- compile_data(
+#'   data = fits,
+#'   output_type = "list",
+#'   list_element = 2
+#' )
+#'
+#' # Compile the PV graphs
+#' graphs2 <- compile_data(
+#'   data = fits,
+#'   output_type = "list",
+#'   list_element = 3
+#' )
+#' }
+fit_PV_curve <- function(data,
+                         varnames = list(
+                           psi = "psi",
+                           mass = "mass",
+                           leaf_mass = "leaf_mass",
+                           bag_mass = "bag_mass",
+                           leaf_area = "leaf_area"
+                         ),
+                         title = NULL) {
+  # Locally bind variables
+  inv_psi <- NULL
+  inv_psi_pred <- NULL
+  leaf_water <- NULL
+  psi <- NULL
+  psi_pred <- NULL
+  `100-RWC` <- NULL
+  # Set variable names
+  data$psi <- data[, varnames$psi]
+  data$mass <- data[, varnames$mass]
+  data$leaf_mass <- data[, varnames$leaf_mass]
+  data$bag_mass <- data[, varnames$bag_mass]
+  data$leaf_area <- data[, varnames$leaf_area]
+  # Generate list for outputs
+  output <- list(NULL)
+  # Generate dataframe for outputs within list
+  output[[1]] <- as.data.frame(rbind(1:8))
+  colnames(output[[1]]) <- c(
+    "SWC",
+    "PI_o",
+    "psi_TLP",
+    "RWC_TLP",
+    "eps",
+    "C_FT",
+    "C_TLP",
+    "C_FTStar"
+  )
+  # Calculate inverse water potential for calculations
+  data$inv_psi <- -1 / data$psi
+  # Assign single value for leaf mass, bag mass, and leaf area
+  # First we assign NULL values to make sure the variable is
+  # locally bound to the function and not integrated into the
+  # global environment
+  leaf_mass <- NULL
+  bag_mass <- NULL
+  leaf_area <- NULL
+  leaf_mass <- data$leaf_mass[1]
+  bag_mass <- data$bag_mass[1]
+  leaf_area <- data$leaf_area[1]
+  # Calculate leaf water
+  data$leaf_water <- data$mass - leaf_mass - bag_mass
+  # Create empty list for regressions
+  water_fit <- list(NULL)
+  # Create vector of r-squared values for model selection
+  # Length is -2 because regression needs > 2 points
+  Rsq <- c(1:(length(data$mass) - 2))
+  # This regression needs to be from beginning to end of linear water loss
+  # Needs at least 3 points, hence i starting at 3, but cap at 5 to avoid
+  # issues if the first three points are not very linear
+  for (i in 3:length(data$mass)) {
+    water_fit[[i - 2]] <- lm(psi ~ leaf_water, data[1:i, ])
+    water_fit[[i - 2]]$Rsq <- summary(water_fit[[i - 2]])$r.squared
+    Rsq[i - 2] <- summary(water_fit[[i - 2]])$r.squared
+  }
+  # Need to select best fit based on r-squared
+  for (i in 1:3) {
+    if (water_fit[[i]]$Rsq == max(Rsq[1:3])) {
+      bestfit <- water_fit[[i]]
+    }
+  }
+  # Calculate saturated water content
+  # This is only for calulating other parameters
+  SWC <- -coef(bestfit)[1] / coef(bestfit)[2]
+  # Calculate saturated water content on leaf mass basis
+  output[[1]]$SWC <- SWC / leaf_mass
+  # Calculate relative water content
+  data$RWC <- data$leaf_water / SWC
+  # Convert RWC to percent and 100 - RWC
+  data$RWC_percent <- 100 * data$RWC
+  data$`100-RWC` <- 100 - data$RWC_percent
+  # Generate predicted psi for psi-water plot
+  data$psi_pred <- coef(bestfit)[[2]] * data$leaf_water + coef(bestfit)[[1]]
+  # Generate psi water plot - lets you see points used for regression
+  output[[2]] <- ggplot(data, aes(x = leaf_water, y = psi)) +
+    labs(y = expression(Psi[leaf] ~ "(MPa)", x = "Mass of water (g)")) +
+    geom_hline(yintercept = 0) +
+    geom_line(aes(y = psi_pred), colour = "Grey", linewidth = 2) +
+    geom_point(size = 2) +
+    theme_bw()
+  # Remove bestfit information to avoid code complications
+  bestfit <- NULL
+  # Generate empty list for predicting turgor loss point
+  psi_fit <- list(NULL)
+  # Generate r-squared vector
+  Rsq <- c(1:(length(data$mass) - 4))
+  # Run regressions, ensuring that there is a minimum of 3 points
+  # i starts at 3 to avoid first 2 points where large changes in psi
+  # can occur. Also finds cutoff observation for other calculations
+  for (i in 3:(length(data$inv_psi) - 2)) {
+    psi_fit[[i - 2]] <- lm(
+      inv_psi ~ `100-RWC`,
+      data[(length(data$inv_psi) - i):length(data$inv_psi), ]
+    )
+    psi_fit[[i - 2]]$Rsq <- summary(psi_fit[[i - 2]])$r.squared
+    psi_fit[[i - 2]]$Obs_cut <- i
+    Rsq[i - 2] <- summary(psi_fit[[i - 2]])$r.squared
+  }
+  # Find best model based on r-squared
+  for (i in 1:length(psi_fit)) {
+    if (psi_fit[[i]]$Rsq == max(Rsq)) {
+      bestfit <- psi_fit[[i]]
+    }
+  }
+  # Calculate psi and RWC at turgor loss point
+  output[[1]]$psi_TLP <- data[bestfit$Obs_cut, ]$psi
+  output[[1]]$RWC_TLP <- data[bestfit$Obs_cut, ]$RWC * 100
+  # Calculate osmotic potential at full turgor
+  output[[1]]$PI_o <- -1 / coef(bestfit)[1]
+  # Caclulate osmotic water potential
+  data$psi_o <- -1 / (coef(bestfit)[1] + coef(bestfit)[2] * data$`100-RWC`)
+  data$psi_p <- data$psi - data$psi_o
+  # Calculate modulus of elasticity at full turgor
+  output[[1]]$eps <- coef(lm(psi_p ~ RWC, data[1:bestfit$Obs_cut, ]))[2]
+  # Calculate relative capacitance at full turgor
+  # Include cutoff observations and points above cutoff
+  output[[1]]$C_FT <- coef(lm(RWC ~ psi, data[1:bestfit$Obs_cut, ]))[2]
+  # Calculate relative capacitance at turgor loss point
+  # Include cutoff observations and points below cutoff
+  output[[1]]$C_TLP <- coef(lm(
+    RWC ~ psi,
+    data[bestfit$Obs_cut:length(data$psi), ]
+  ))[2]
+  # Calculate absolute capacitance per area at full turgor
+  output[[1]]$C_FTStar <- output[[1]]$C_FT * SWC / 18 / (leaf_area / 10000)
+  # Calculate predicted inverse psi for graphing
+  data$inv_psi_pred <- coef(bestfit)[[2]] * data$`100-RWC` + coef(bestfit)[[1]]
+  # Graph the turgor loss point graph
+  output[[3]] <- ggplot(data, aes(x = `100-RWC`, y = inv_psi)) +
+    ggtitle(label = title) +
+    labs(y = expression("1 / " * Psi ~ "(MP" * a^{
+      -1
+    } * ")")) +
+    geom_line(aes(y = inv_psi_pred), linewidth = 3, colour = "Grey") +
+    geom_line(linewidth = 1, colour = "Black") +
+    geom_point(size = 4) +
+    theme_bw()
+  # Add names to output list
+  names(output) <- c(
+    "PV Parameters",
+    "Water Mass - Water Potential Graph",
+    "TLP Graph"
+  )
+  # Return output
+  return(output)
+}

data/R/fit_aci_response.R

@@ -0,0 +1,502 @@
+#' Fitting ACi curves
+#'
+#' @param data Dataframe for A-Ci curve fitting
+#' @param varnames List of variable names. varnames = list(A_net = "A_net",
+#' T_leaf = "T_leaf", C_i = "C_i", PPFD = "PPFD", g_mc = "g_mc"), where A_net
+#' is net CO2 assimilation, T_leaf is leaf temperature in Kelvin, C_i is
+#' intercellular CO2 concentration in umol/mol, PPFD is incident irradiance
+#' in umol m-2 s-1 (note that it is ASSUMED to be absorbed irradiance, so be
+#' sure to adjust according to light absorbance and PSI/PSII partitioning
+#' accordingly OR interpret the resultant values of J and J_max with caution),
+#' g_mc is mesophyll conductance to CO2 in mol m-2 s-1 Pa-1.
+#' @param P Atmospheric pressure in kPa
+#' @param fitTPU Should triose phosphate utilization (V_TPU) be fit?
+#' @param alpha_g Fraction of respiratory glycolate carbon that is not returned
+#' to the chloroplast (von Caemmerer, 2000). If ACi curves show high-CO2
+#' decline, then this value should be > 0.
+#' @param R_d_meas Measured value of respiratory CO2 efflux in umol m-2 s-1.
+#' Input value should be positive to work as expected with the equations.
+#' @param useR_d Use a measured value of R_d? Set to TRUE if using R_d_meas.
+#' @param useg_mc Use mesophyll conductance? Set to TRUE if specifying g_mc
+#' in varnames above.
+#' @param useg_mct Use mesophyll conductance temperature response? Set to TRUE
+#' if using a temperature response of mesophyll conductance.
+#' @param usegamma_star Specify gamma_star value? If FALSE, uses a temperature
+#' response function with Nicotiana tabacum defaults from Bernacchi et al.
+#' 2001.
+#' @param useK_M Specify K_M? If FALSE, uses an Arrhenius temperature response
+#' function with Nicotiana tabacum defaults from Bernacchi et al. 2001.
+#' @param useK_C_K_O Use individual carboxylation/oxygenation constants for
+#' rubisco? If TRUE, need to specify values at 25C and activation energy for
+#' the Arrhenius temperature response function.
+#' @param alpha Quantum yield of CO2 assimilation
+#' @param theta_J Curvature of the photosynthetic light response curve
+#' @param gamma_star25 gamma_star at 25C in umol mol-1
+#' @param Ea_gamma_star Activation energy of gamma_star in J mol-1
+#' @param K_M25 Michaelis-Menten constant for rubisco at 25C
+#' @param Ea_K_M Activation energy for K_M in J mol-1
+#' @param g_mc25 Mesophyll conductance at 25C in mol m-2 s-1
+#' @param Ea_g_mc Activation energy of g_mc in J mol-1
+#' @param K_C25 Michaelis-Menten constant for rubisco carboxylation at 25C
+#' @param Ea_K_C Activation energy for K_C in J mol-1
+#' @param K_O25 Michaelis-Menten constant for rubisco oxygenation at 25C
+#' @param Ea_K_O Activation energy for K_O in J mol-2
+#' @param Oconc O2 concentration in %. Used with P to calculate
+#' intracellular O2 when using K_C_K_O
+#' @param gamma_star_set Value of gamma_star to use (in ppm) if
+#' usegamma_star = TRUE
+#' @param K_M_set Value of K_M to use if useK_M = TRUE
+#' @param ... Other arguments to pass on
+#'
+#' @return fit_aci_response fits ACi curves using an approach similar to
+#' Gu et al. 2010. Iterates all possible C_i transition points and checks for
+#' inadmissible curve fits. If no curves are admissible (either due to poor data
+#' or poor assumed parameters), the output will include a dataframe of NA values.
+#' Default parameters are all from Bernacchi et al. 2001, 2002.
+#'
+#' @references
+#' Bernacchi CJ, Singsaas EL, Pimentel C, Portis AR, Long SP. 2001. Improved
+#' temperature response functions for models of rubisco-limited photosynthesis.
+#' Plant Cell Environment 24:253-259.
+#'
+#' Bernacchi CJ, Portis AR, Nakano H, von Caemmerer S, Long SP. 2002. Temperature
+#' response of mesophyll conductance. Implications for the determination of rubisco
+#' enzyme kinetics and for limitations to photosynthesis in vivo. Plant Physiology
+#' 130:1992-1998.
+#'
+#' Gu L, Pallardy SG, Tu K, Law BE, Wullschleger SD. 2010. Reliable estimation
+#' of biochemical parameters from C3 leaf photosynthesis-intercellular carbon
+#' dioxide response curves. Plant Cell Environment 33:1852-1874.
+#'
+#' von Caemmerer S. 2000. Biochemical models of leaf photosynthesis. CSIRO
+#' Publishing, Collingwood.
+#'
+#' @importFrom ggplot2 element_blank
+#' @importFrom ggplot2 geom_line
+#' @importFrom ggplot2 ggplot
+#' @importFrom ggplot2 scale_color_manual
+#' @importFrom ggplot2 scale_y_continuous
+#' @importFrom stats coef
+#' @importFrom stats lm
+#' @importFrom stats sd
+#' @export
+#'
+#' @examples
+#' \donttest{
+#' # Read in your data
+#' # Note that this data is coming from data supplied by the package
+#' # hence the complicated argument in read.csv()
+#' # This dataset is a CO2 by light response curve for a single sunflower
+#' data <- read.csv(system.file("extdata", "A_Ci_Q_data_1.csv",
+#'   package = "photosynthesis"
+#' ))
+#'
+#' # Define a grouping factor based on light intensity to split the ACi
+#' # curves
+#' data$Q_2 <- as.factor((round(data$Qin, digits = 0)))
+#'
+#' # Convert leaf temperature to K
+#' data$T_leaf <- data$Tleaf + 273.15
+#'
+#' # Fit ACi curve. Note that we are subsetting the dataframe
+#' # here to fit for a single value of Q_2
+#' fit <- fit_aci_response(data[data$Q_2 == 1500, ],
+#'   varnames = list(
+#'     A_net = "A",
+#'     T_leaf = "T_leaf",
+#'     C_i = "Ci",
+#'     PPFD = "Qin"
+#'   )
+#' )
+#'
+#' # View fitted parameters
+#' fit[[1]]
+#'
+#' # View graph
+#' fit[[2]]
+#'
+#' # View data with modelled parameters attached
+#' fit[[3]]
+#'
+#' # Fit many curves
+#' fits <- fit_many(
+#'   data = data,
+#'   varnames = list(
+#'     A_net = "A",
+#'     T_leaf = "T_leaf",
+#'     C_i = "Ci",
+#'     PPFD = "Qin"
+#'   ),
+#'   funct = fit_aci_response,
+#'   group = "Q_2"
+#' )
+#'
+#' # Print the parameters
+#' # First set of double parentheses selects an individual group value
+#' # Second set selects an element of the sublist
+#' fits[[3]][[1]]
+#'
+#' # Print the graph
+#' fits[[3]][[2]]
+#'
+#' # Compile graphs into a list for plotting
+#' fits_graphs <- compile_data(fits,
+#'   list_element = 2
+#' )
+#'
+#' # Compile parameters into dataframe for analysis
+#' fits_pars <- compile_data(fits,
+#'   output_type = "dataframe",
+#'   list_element = 1
+#' )
+#' }
+fit_aci_response <- function(data,
+                             varnames = list(
+                               A_net = "A_net",
+                               T_leaf = "T_leaf",
+                               C_i = "C_i",
+                               PPFD = "PPFD",
+                               g_mc = "g_mc"
+                             ),
+                             P = 100,
+                             fitTPU = TRUE,
+                             alpha_g = 0,
+                             R_d_meas = NULL,
+                             useR_d = FALSE,
+                             useg_mc = FALSE,
+                             useg_mct = FALSE,
+                             usegamma_star = FALSE,
+                             useK_M = FALSE,
+                             useK_C_K_O = FALSE,
+                             alpha = 0.24,
+                             theta_J = 0.85,
+                             gamma_star25 = 42.75,
+                             Ea_gamma_star = 37830,
+                             K_M25 = 718.40,
+                             Ea_K_M = 65508.28,
+                             g_mc25 = 0.08701,
+                             Ea_g_mc = 0,
+                             K_C25 = NULL,
+                             Ea_K_C = NULL,
+                             K_O25 = NULL,
+                             Ea_K_O = NULL,
+                             Oconc = 21,
+                             gamma_star_set = NULL,
+                             K_M_set = NULL,
+                             ...) {
+  # Locally bind variables - avoids notes on check package
+  C_i <- NULL
+  A_model <- NULL
+  A_carbox <- NULL
+  A_regen <- NULL
+  A_tpu <- NULL
+  A_net <- NULL
+  PPFD <- NULL
+  # Set variable names
+  data$C_i <- data[, varnames$C_i]
+  data$A_net <- data[, varnames$A_net]
+  data$PPFD <- data[, varnames$PPFD]
+  data$T_leaf <- data[, varnames$T_leaf]
+  outputs <- vector("list", 3)
+  # Order data by increasing C_i, avoids calculation issues
+  data <- data[order(data$C_i), ]
+  # Convert O2 concentration to partial pressure
+  O <- Oconc * P / 100
+  # Create grid of possible C_i transition points
+  ci <- data[order(data$C_i), ]$C_i
+  nci <- length(ci)
+  citransitions <- diff(ci) / 2 + ci[-nci]
+  # Make sure there is a minimum of 3 points for V_cmax fitting
+  citransitions1 <- citransitions[3:length(citransitions)]
+  if (!fitTPU) {
+    citransitions2 <- max(ci) + 1
+  } else {
+    citransitions2 <- c(max(ci) + 1, rev(citransitions1))
+  }
+  # Create combinations of ci1 and ci2 to fit
+  citransdf <- expand.grid(ci1 = citransitions1, ci2 = citransitions2)
+  citransdf <- citransdf[citransdf$ci1 <= citransdf$ci2, ]
+  # Mesophyll conductance calculations
+  if (!useg_mc) {
+    # Assumes g_mc is infinite
+    data$C <- data$C_i * P / 100
+  } else {
+    # Uses measured values of g_mc
+    data$g_mc <- data[, varnames$g_mc]
+    data$C <- (data$C_i - data$A_net / data$g_mc) * P / 100
+  }
+  if (useg_mct) {
+    # Calculates g_mc based on a specified temperature response
+    data$g_mc <- g_mc25 * t_response_arrhenius(
+      T_leaf = data$T_leaf,
+      Ea = Ea_g_mc
+    )
+    data$C <- (data$C_i - data$A_net / data$g_mc) * P / 100
+  }
+  # gamma_star settings
+  if (!usegamma_star) {
+    # Calculates gamma_star based on temperature response function
+    gamma_star <- gamma_star25 * t_response_arrhenius(
+      T_leaf = mean(data$T_leaf),
+      Ea = Ea_gamma_star
+    ) * P / 100
+  } else {
+    # Uses specified gamma_star, converts to partial pressure
+    gamma_star <- gamma_star_set * P / 100
+  }
+  # K_M settings
+  if (!useK_M) {
+    # Calculates K_M based on temperature response
+    K_M <- K_M25 * t_response_arrhenius(
+      T_leaf = mean(data$T_leaf),
+      Ea = Ea_K_M
+    )
+  } else {
+    # Uses specified K_M
+    K_M <- K_M_set
+  }
+  if (useK_C_K_O) {
+    # Calculates K_M based on temperature responses of K_C and K_O
+    K_C <- K_C25 * t_response_arrhenius(
+      T_leaf = mean(data$T_leaf),
+      Ea = Ea_K_C
+    )
+    K_O <- K_O25 * t_response_arrhenius(
+      T_leaf = mean(data$T_leaf),
+      Ea = Ea_K_O
+    )
+    K_M <- K_C * (1 + O / K_O)
+  }
+  # Generate x-variables for linearized prediction of V_cmax, J_max, V_TPU
+  # Note this is based on the Duursma (2015) approach eto Gu et al. 2010
+  data$V_cmax_pred <- (data$C - gamma_star) / (data$C + K_M)
+  data$J_max_pred <- (data$C - gamma_star) / (data$C + 2 * gamma_star)
+  data$V_TPU_part <- (data$C - gamma_star) / (data$C - (1 + 3 * alpha_g) *
+    gamma_star)
+  # Create dataframe for all possible curve fits
+  poss_fits <- data.frame(matrix(0,
+    nrow = nrow(citransdf),
+    ncol = 16
+  ))
+  # Add column names
+  colnames(poss_fits) <- c(
+    "Num", "V_cmax", "V_cmax_se", "J_max",
+    "J", "J_se", "V_TPU", "V_TPU_se", "R_d", "R_d_se",
+    "cost", "citransition1", "citransition2",
+    "V_cmax_pts", "J_max_pts", "V_TPU_pts"
+  )
+  # Fit all possible citransition combinations
+  for (i in seq_len(nrow(citransdf))) {
+    # Locally bind variables
+    cost <- NULL
+    V_cmax_fit <- NULL
+    J_max_fit <- NULL
+    V_TPU <- NULL
+    datc <- NULL
+    datj <- NULL
+    datp <- NULL
+    datcomp <- NULL
+    # CO2-limited points
+    datc <- data[data$C_i < citransdf$ci1[i], ]
+    # RuBP regeneration-limited points
+    datj <- data[data$C_i > citransdf$ci1[i] &
+      data$C_i < citransdf$ci2[i], ]
+    # V_TPU-limited points
+    datp <- data[data$C_i > citransdf$ci2[i], ]
+    # Fits V_cmax
+    if (!useR_d) {
+      # Fit R_d and V_cmax
+      fitc <- lm(A_net ~ V_cmax_pred, data = datc)
+      R_d_fit <- coef(fitc)[[1]]
+      R_d_se <- summary(fitc)$coefficients[1, 2]
+      V_cmax_fit <- coef(fitc)[[2]]
+      V_cmax_se <- summary(fitc)$coefficients[2, 2]
+      datc$A_gross <- datc$A_net - R_d_fit
+    } else {
+      # Use R_d and fit V_cmax
+      R_d_fit <- -R_d_meas
+      datc$A_gross <- datc$A_net - R_d_fit
+      fitc <- lm(A_gross ~ V_cmax_pred - 1, data = datc)
+      V_cmax_fit <- coef(fitc)[[1]]
+      V_cmax_se <- summary(fitc)$coefficients[, 2]
+    }
+    # Fit J and J_max
+    if (nrow(datj) > 0) {
+      datj$A_gross <- datj$A_net - R_d_fit
+      if (nrow(datj) == 1) {
+        # Calculates J_max based on one point
+        J_fit <- 4 * datj$A_gross / datj$J_max_pred
+        J_se <- NA
+        J_max_fit <- suppressWarnings(calculate_jmax(mean(data$PPFD),
+          alpha,
+          J = J_fit, theta_J
+        ))
+      } else {
+        # Calculates J_max based on a linear regression fit
+        fitj <- lm(A_gross ~ J_max_pred - 1, data = datj)
+        J_fit <- 4 * coef(fitj)[[1]]
+        J_se <- summary(fitj)$coefficients[2]
+        J_max_fit <- suppressWarnings(calculate_jmax(mean(data$PPFD),
+          alpha,
+          J = J_fit, theta_J
+        ))
+      }
+    } else {
+      # Assign J_max a value of 10 ^ 6 if there's no RuBP limitation
+      J_max_fit <- 10^6
+      J_max_SS <- 0
+      J_se <- NA
+    }
+    # Calculating V_TPU limitations
+    if (nrow(datp) == 1 && nrow(datj) == 0) {
+      # Assign V_TPU a value of 1000 if there is only 1 assigned
+      # point and no RuBP-limited points
+      datp$A_gross <- datp$A_net - R_d_fit
+      V_TPU <- 1000
+      V_TPU_SS <- 0
+      V_TPU_se <- NA
+    } else {
+      # This section covers if there are no V_TPU-limited points
+      datp$A_gross <- datp$A_net - R_d_fit
+      V_TPU <- 1000 # same as default in Photosyn
+      V_TPU_SS <- 0
+      V_TPU_se <- NA
+    }
+    # Calculates V_TPU limitations if there are at least 3 points
+    # to ensure more reliable fit
+    if (nrow(datp) > 2) {
+      datp$A_gross <- datp$A_net - R_d_fit
+      V_TPU_vals <- (1 / 3) * datp$A_gross / datp$V_TPU_part
+      V_TPU <- mean(V_TPU_vals)
+      V_TPU_se <- sd(V_TPU_vals) / sqrt(length(V_TPU_vals))
+    }
+    # If V_TPU is fit to be < 0, assign value of 1000. Avoids
+    # strange issues.
+    if (V_TPU < 0) {
+      V_TPU <- 1000
+      V_TPU_SS <- 0
+      V_TPU_se <- NA
+    }
+    # Calculate rates of photosynthesis for each limitation state and sums of
+    # squares for model-wise cost function
+    # CO2 limitations
+    datc$A <- V_cmax_fit * (datc$C - gamma_star) / (datc$C + K_M) + R_d_fit
+    datc$SS <- (datc$A - datc$A_net)^2
+    V_cmax_SS <- sum(datc$SS)
+    # RuBP limitations
+    datj$A <- J_fit * (datj$C - gamma_star) /
+      (4 * datj$C + 8 * gamma_star) + R_d_fit
+    datj$SS <- (datj$A - datj$A_net)^2
+    J_max_SS <- sum(datj$SS)
+    # V_TPU limitations
+    datp$A <- 3 * V_TPU * (datp$C - gamma_star) /
+      (datp$C - (1 + 3 * alpha_g) * gamma_star / datp$C) + R_d_fit
+    datp$SS <- (datp$A - datp$A_net)^2
+    V_TPU_SS <- sum(datp$SS)
+    # Calculate cost functions
+    cost <- 1 / 2 * (V_cmax_SS + J_max_SS + V_TPU_SS)
+    # Bind calculated data
+    datcomp <- rbind(datc, datj, datp)
+    # Add outputs to possible fits
+    poss_fits$V_cmax[i] <- V_cmax_fit
+    poss_fits$V_cmax_se[i] <- V_cmax_se
+    poss_fits$J_max[i] <- J_max_fit
+    poss_fits$J[i] <- J_fit
+    poss_fits$J_se[i] <- J_se
+    poss_fits$V_TPU[i] <- V_TPU
+    poss_fits$V_TPU_se[i] <- V_TPU_se
+    poss_fits$R_d[i] <- R_d_fit
+    poss_fits$R_d_se[i] <- R_d_se
+    poss_fits$V_cmax_pts[i] <- nrow(datc)
+    poss_fits$J_max_pts[i] <- nrow(datj)
+    poss_fits$V_TPU_pts[i] <- nrow(datp)
+    poss_fits$cost[i] <- cost
+    poss_fits$citransition1[i] <- citransdf$ci1[i]
+    poss_fits$citransition2[i] <- citransdf$ci2[i]
+  } # End curve fitting of all possible C_i transitions
+  # Select fit with minimized cost function
+  best_fits <- poss_fits[poss_fits$cost == min(poss_fits$cost), ]
+  # New segment for sensitivity analysis
+  # Adds values for assumed constants to the output dataframe
+  best_fits$alpha <- alpha
+  best_fits$alpha_g <- alpha_g
+  best_fits$gamma_star25 <- gamma_star25
+  best_fits$Ea_gamma_star <- Ea_gamma_star
+  best_fits$K_M25 <- K_M25
+  best_fits$Ea_K_M <- Ea_K_M
+  best_fits$g_mc25 <- g_mc25
+  best_fits$Ea_g_mc <- Ea_g_mc
+  best_fits$K_C25 <- K_C25
+  best_fits$Ea_K_C <- Ea_K_C
+  best_fits$K_O25 <- K_O25
+  best_fits$Ea_K_O <- Ea_K_O
+  best_fits$Oconc <- Oconc
+  best_fits$theta_J <- theta_J
+  # Calculate net photosynthetic rates
+  data$A_carbox <- best_fits$V_cmax * data$C /
+    (data$C + K_M) * (1 - gamma_star / data$C) + best_fits$R_d
+  data$A_regen <- calculate_j(
+    PPFD = mean(data$PPFD), alpha = alpha,
+    J_max = best_fits$J_max, theta_J = theta_J
+  ) *
+    (data$C - gamma_star) / (4 * data$C + 8 * gamma_star) + best_fits$R_d
+  data$A_tpu <- 3 * best_fits$V_TPU /
+    (1 - 0.5 * (1 + 3 * alpha_g) * (2 * gamma_star / data$C)) *
+    (1 - gamma_star / data$C) + best_fits$R_d
+  # Calculate gross photosynthetic rates
+  data$W_carbox <- data$A_carbox - best_fits$R_d
+  data$W_regen <- data$A_regen - best_fits$R_d
+  data$W_tpu <- data$A_tpu - best_fits$R_d
+  # Create empty variable for modelled CO2 assimilation
+  data$A_model <- rep(NA, nrow(data))
+  # To avoid issues with graphing and cases where W_j drops below W_c
+  # at very low CO2, for the first few points, A_model is calculated
+  # with W_c only - plantecophys took an approach where Aj was fixed
+  # on the graph until a certain C_i to avoid this same issue.
+  for (i in 1:(best_fits$V_cmax_pts - 2)) {
+    data$A_model[i] <- data$W_carbox[i] + best_fits$R_d
+  }
+  if (best_fits$V_TPU == 1000) {
+    for (i in (best_fits$V_cmax_pts - 1):nrow(data)) {
+      data$A_model[i] <- min(data$W_carbox[i], data$W_regen[i]) + best_fits$R_d
+    }
+  } else {
+    for (i in (best_fits$V_cmax_pts - 1):nrow(data)) {
+      data$A_model[i] <- min(
+        data$W_carbox[i], data$W_regen[i],
+        data$W_tpu[i]
+      ) + best_fits$R_d
+    }
+  }
+  # Assign best fit to output element 1
+  outputs[[1]] <- best_fits
+  # Assign graph to output element 2
+  outputs[[2]] <- ggplot(data, aes(x = C_i, y = A_model)) +
+    scale_y_continuous(limits = c(
+      min(c(data$A_model, data$A_net)) - 3,
+      max(c(data$A_model, data$A_net)) + 3
+    )) +
+    geom_line(aes(color = "black"), linewidth = 4) +
+    geom_line(aes(y = A_carbox, color = "blue"), linewidth = 2) +
+    geom_line(aes(y = A_regen, color = "orange"), linewidth = 2) +
+    geom_line(aes(y = A_tpu, color = "red"), linewidth = 2) +
+    geom_point(aes(y = A_net),
+      color = "black", fill = "white",
+      size = 2, shape = 21
+    ) +
+    scale_color_manual(
+      labels = c("Amod", "Ac", "Aj", "Ap", "Anet"),
+      values = c(
+        "black", "blue", "orange",
+        "red", "white"
+      )
+    ) +
+    theme_bw() +
+    theme(legend.title = element_blank())
+  # Assign dataframe to output element 3
+  outputs[[3]] <- data
+  # Add names to list output
+  names(outputs) <- c("Fitted Parameters", "Plot", "Data")
+  # Return output list
+  return(outputs)
+} # End function

data/R/fit_aq_response.R

@@ -0,0 +1,489 @@
+#' Fit photosynthetic light-response curves
+#' 
+#' @description We recommend using [fit_photosynthesis()] with argument `.photo_fun = "aq_response"` rather than calling this function directly.
+#' 
+#' @inheritParams fit_photosynthesis
+#' @param usealpha_Q Flag. Should light intensity be multiplied by `alpha_Q` before fitting? Default is FALSE (i.e. assume that '.Q' is absorbed light).
+#' @param alpha_Q Number. Absorbance of incident light. Default value is 0.84. Ignored if `usealpha_Q = FALSE`.
+#' 
+#' @return 
+#' 
+#' * If `.method = 'ls'`: an [stats::nls()] object.
+#' * If `.method = 'brms'`: a [brms::brmsfit()] object.
+#' 
+#' @note Rd fitted in this way is essentially the same as the Kok (1956) method, and 
+#' represents a respiration value in the light that may not be accurate. 
+#' Rd output should thus be interpreted more as a residual parameter to ensure 
+#' an accurate fit of the light response parameters. Model originally from 
+#' Marshall & Biscoe (1980).
+#'
+#' @references
+#' Marshall B, Biscoe P. 1980. A model for C3 leaves describing the
+#' dependence of net photosynthesis on irradiance. J Ex Bot 31:29-39
+#'
+#' @export
+#'
+#' @examples
+#' \donttest{
+#' 
+#' library(broom)
+#' library(dplyr)
+#' library(photosynthesis)
+#' 
+#' # Read in your data
+#' dat = system.file("extdata", "A_Ci_Q_data_1.csv", package = "photosynthesis") |>
+#'   read.csv() |>
+#'   # Set grouping variable
+#'   mutate(group = round(CO2_s, digits = 0)) |>
+#'   # For this example, round sequentially due to CO2_s set points
+#'   mutate(group = as.factor(round(group, digits = -1)))
+#' 
+#' # Fit one light-response curve
+#' fit = fit_photosynthesis(
+#'   .data = filter(dat, group == 600),
+#'   .photo_fun = "aq_response",
+#'   .vars = list(.A = A, .Q = Qabs),
+#' )
+#' 
+#' # The 'fit' object inherits class 'nls' and many methods can be used
+#' 
+#' ## Model summary:
+#' summary(fit)
+#' 
+#' ## Estimated parameters:
+#' coef(fit)
+#' 
+#' ## 95% confidence intervals:
+#' confint(fit)
+#' 
+#' ## Tidy summary table using 'broom::tidy()'
+#' tidy(fit, conf.int = TRUE, conf.level = 0.95)
+#' 
+#' # Fit multiple curves with **photosynthesis** and **purrr**
+#' 
+#' library(purrr)
+#' 
+#' fits = dat |>
+#'   split(~ group) |>
+#'   map(fit_photosynthesis, .photo_fun = "aq_response", .vars = list(.A = A, .Q = Qabs))
+#' 
+#' }
+#' 
+#' @md
+fit_aq_response2 = function(
+    .data,
+    .model = "default",
+    .method = "ls",
+    usealpha_Q = FALSE,
+    alpha_Q = 0.84,
+    quiet = FALSE,
+    brm_options = NULL
+  ) {
+  
+  # Checks
+  checkmate::assert_flag(usealpha_Q)
+  checkmate::assert_number(alpha_Q, na.ok = !usealpha_Q)
+  
+  # Set light intensity dependent on whether it is incident or
+  # absorbed that you want the variables on
+  .data = dplyr::mutate(.data, .Qabs = .Q * ifelse(usealpha_Q, alpha_Q, 1)) |>
+    dplyr::select(.A, .Q, .Qabs)
+
+  # Fit AQ response model
+  fit = switch(
+    .method,
+    ls = fit_aq_response2_ls(.data, .model),
+    brms = fit_aq_response2_brms(.data, .model, brm_options)
+  )
+ 
+  fit 
+  
+}
+
+#' Fit light response using [minpack.lm::nlsLM()]
+#' @inheritParams fit_aq_response2
+#' @noRd
+fit_aq_response2_ls = function(.data, .model, ...) {
+  
+  requireNamespace("minpack.lm") || stop("Package not loaded: minpack.lm")
+  
+  do.call(
+    glue::glue("fit_aq_response2_{.model}_ls"),
+    args = list(.data = .data, ...)
+  )
+  
+}
+
+#' Fit light response using [brms::brm()]
+#' @noRd
+fit_aq_response2_brms = function(.data, .model, brm_options, ...) {
+  
+  requireNamespace("brms") || stop("Package not loaded: brms")
+  
+  lifecycle::signal_stage("experimental", what = "fit_aq_response2(.method = 'brms')")
+  
+  do.call(
+    glue::glue("fit_aq_response2_{.model}_brms"),
+    args = list(.data = .data, brm_options = brm_options, ...)
+  )
+  
+}
+
+#' Fit photosynthetic nonrectangular hyperbola light-response curves (Marshall & Biscore 1980) using least-squares methods
+#' @inheritParams fit_aq_response2
+#' @noRd
+
+fit_aq_response2_marshall_biscoe_1980_ls = function(.data, ...) {
+  
+  minpack.lm::nlsLM(
+    data = .data,
+    .A ~ marshall_biscoe_1980(Q_abs = .data[[".Qabs"]], k_sat, phi_J, theta_J) - Rd,
+    # Attempt to estimate starting parameters
+    start = get_init_aq_response(.data),
+    # Set lower limits
+    lower = c(min(.data[[".A"]]), rep(0, 3)),
+    # set upper limits
+    upper = c(10 * max(abs(.data[[".A"]])), 0.5, 1, max(.data[[".A"]])),
+    # set max iterations for curve fitting
+    control = nls.lm.control(maxiter = 100)
+  )
+  
+}
+
+#' Fit photosynthetic nonrectangular hyperbola light-response curves (Marshall & Biscore 1980) using Bayesian methods
+#' @inheritParams fit_aq_response2
+#' @noRd
+fit_aq_response2_marshall_biscoe_1980_brms = function(.data, brm_options, ...) {
+  
+  do.call(
+    brms::brm,
+    args = c(
+      brm_options,
+      list(
+        formula = brms::bf(
+          .A ~ ((Asat + inv_logit(logitPhiJ) * .Qabs) -
+                 sqrt((Asat + inv_logit(logitPhiJ) * .Qabs) ^ 2 -
+                        4 * Asat * inv_logit(logitPhiJ) * .Qabs * inv_logit(logitThetaJ))) /
+            (2 * inv_logit(logitThetaJ)) - Rd,
+          Asat ~ 1,
+          logitPhiJ ~ 1,
+          logitThetaJ ~ 1,
+          Rd ~ 1,
+          nl = TRUE
+        ), 
+        data = .data,
+        prior = c(
+          brms::prior(normal(20, 10), nlpar = "Asat", lb = 0),
+          brms::prior(normal(-2.5, 0.5), nlpar = "logitPhiJ"),
+          brms::prior(normal(2.5, 0.5), nlpar = "logitThetaJ"),
+          brms::prior(normal(2, 1), nlpar = "Rd", lb = 0)
+        )
+      )
+    )
+  )
+  
+}
+
+#' Fit photosynthetic nonrectangular hyperbola light-response curves (Marshall & Biscore 1980) and photoinhibition using least-squares methods
+#' @inheritParams fit_aq_response2
+#' @noRd
+
+fit_aq_response2_photoinhibition_ls = function(.data, ...) {
+  
+  minpack.lm::nlsLM(
+    data = .data,
+    .A ~ photoinhibition(Q_abs = .data[[".Qabs"]], k_sat, phi_J, theta_J, b_inh) - Rd,
+    # Attempt to estimate starting parameters
+    start = c(get_init_aq_response(.data), b_inh = 0),
+    # Set lower limits
+    lower = c(min(.data[[".A"]]), rep(0, 3), -0.1),
+    # set upper limits
+    upper = c(10 * max(abs(.data[[".A"]])), 0.5, 1, max(.data[[".A"]]), 0.1),
+    # set max iterations for curve fitting
+    control = nls.lm.control(maxiter = 100)
+  )
+  
+}
+
+#' Fit photosynthetic nonrectangular hyperbola light-response curves (Marshall & Biscore 1980) and photoinhibition using Bayesian methods
+#' @inheritParams fit_aq_response2
+#' @noRd
+fit_aq_response2_photoinhibition_brms = function(.data, brm_options, ...) {
+  
+  do.call(
+    brms::brm,
+    args = c(
+      brm_options,
+      list(
+        formula = brms::bf(
+          .A ~ ((Asat - bInh * .Qabs + inv_logit(logitPhiJ) * .Qabs) -
+                  sqrt((Asat + inv_logit(logitPhiJ) * .Qabs) ^ 2 -
+                         4 * Asat * inv_logit(logitPhiJ) * .Qabs * inv_logit(logitThetaJ))) /
+            (2 * inv_logit(logitThetaJ)) - Rd,
+          Asat ~ 1,
+          bInh ~ 1,
+          logitPhiJ ~ 1,
+          logitThetaJ ~ 1,
+          Rd ~ 1,
+          nl = TRUE
+        ), 
+        data = .data,
+        prior = c(
+          brms::prior(normal(20, 10), nlpar = "Asat", lb = 0),
+          brms::prior(normal(0, 0.1), nlpar = "bInh"),
+          brms::prior(normal(-2.5, 0.5), nlpar = "logitPhiJ"),
+          brms::prior(normal(2.5, 0.5), nlpar = "logitThetaJ"),
+          brms::prior(normal(2, 1), nlpar = "Rd", lb = 0)
+        )
+      )
+    )
+  )
+  
+}
+
+#' Get list of starting values for `fit_aq_response()`
+#' @noRd
+# Get initial values
+get_init_aq_response = function(.data) {
+  
+  x1 = try({unname(coef(lm(.A ~ .Qabs, dplyr::filter(.data, .Qabs < 300))))}, silent = TRUE)
+  if (inherits(x1, "try-error")) x1 = c(0.06, 1)
+  
+  list(
+    k_sat = max(.data[[".A"]]),
+    phi_J = x1[2],
+    theta_J = 0.85,
+    Rd = -x1[1]
+  )
+  
+}
+
+#' Fitting light responses of net CO2 assimilation
+#'
+#' @description 
+#' `r lifecycle::badge("deprecated")`
+#' 
+#' Please use `fit_aq_response2()`.
+#' 
+#' @param data Dataframe containing CO2 assimilation light response
+#' @param varnames Variable names where varnames = list(A_net = "A_net",
+#' PPFD = "PPFD"). A_net is net CO2 assimilation in umol m-2 s-1, PPFD is
+#' incident irradiance. PPFD can be corrected for light absorbance by using
+#' useapha_Q and setting alpha_Q.
+#' @param usealpha_Q Correct light intensity for absorbance? Default is FALSE.
+#' @param alpha_Q Absorbance of incident light. Default value is 0.84.
+#' @param title Title for graph
+#'
+#' @return fit_aq_response fits the light response of net CO2 assimilation.
+#' Output is a dataframe containing light saturated net CO2 assimilation,
+#' quantum yield of CO2 assimilation (phi_J), curvature of the light response
+#' (theta_J), respiration (Rd), light compensation point (LCP), and residual
+#' sum of squares (resid_SS). Note that Rd fitted in this way is essentially
+#' the same as the Kok method, and represents a respiration value in the
+#' light that may not be accurate. Rd output should thus be interpreted more
+#' as a residual parameter to ensure an accurate fit of the light response
+#' parameters. Model originally from Marshall & Biscoe 1980.
+#'
+#' @references
+#' Marshall B, Biscoe P. 1980. A model for C3 leaves describing the
+#' dependence of net photosynthesis on irradiance. J Ex Bot 31:29-39
+#'
+#' @export
+#'
+#' @examples
+#' \donttest{
+#' # Read in your data
+#' # Note that this data is coming from data supplied by the package
+#' # hence the complicated argument in read.csv()
+#' # This dataset is a CO2 by light response curve for a single sunflower
+#' data = read.csv(system.file("extdata", "A_Ci_Q_data_1.csv",
+#'   package = "photosynthesis"
+#' ))
+#'
+#' # Fit many AQ curves
+#' # Set your grouping variable
+#' # Here we are grouping by CO2_s and individual
+#' data$C_s = (round(data$CO2_s, digits = 0))
+#'
+#' # For this example we need to round sequentially due to CO2_s setpoints
+#' data$C_s = as.factor(round(data$C_s, digits = -1))
+#'
+#' # To fit one AQ curve
+#' fit = fit_aq_response(data[data$C_s == 600, ],
+#'   varnames = list(
+#'     A_net = "A",
+#'     PPFD = "Qin"
+#'   )
+#' )
+#'
+#' # Print model summary
+#' summary(fit[[1]])
+#'
+#' # Print fitted parameters
+#' fit[[2]]
+#'
+#' # Print graph
+#' fit[[3]]
+#'
+#' # Fit many curves
+#' fits = fit_many(
+#'   data = data,
+#'   varnames = list(
+#'     A_net = "A",
+#'     PPFD = "Qin",
+#'     group = "C_s"
+#'   ),
+#'   funct = fit_aq_response,
+#'   group = "C_s"
+#' )
+#'
+#' # Look at model summary for a given fit
+#' # First set of double parentheses selects an individual group value
+#' # Second set selects an element of the sublist
+#' summary(fits[[3]][[1]])
+#'
+#' # Print the parameters
+#' fits[[3]][[2]]
+#'
+#' # Print the graph
+#' fits[[3]][[3]]
+#'
+#' # Compile graphs into a list for plotting
+#' fits_graphs = compile_data(fits,
+#'   list_element = 3
+#' )
+#'
+#' # Compile parameters into dataframe for analysis
+#' fits_pars = compile_data(fits,
+#'   output_type = "dataframe",
+#'   list_element = 2
+#' )
+#' }
+#' 
+#' @md
+fit_aq_response = function(
+    data,
+    varnames = list(
+      A_net = "A_net",
+      PPFD = "PPFD"
+    ),
+    usealpha_Q = FALSE,
+    alpha_Q = 0.84,
+    title = NULL
+) {
+  
+  lifecycle::deprecate_warn(
+    "2.1.1", "fit_aq_response()", 
+    "fit_photosynthesis(.photo_fun = 'aq_response')", 
+    always = FALSE
+  )
+  
+  # Locally bind variables - avoids notes on check package
+  A_net = NULL
+  Q_abs = NULL
+  # Set variable names
+  data$A_net = data[, varnames$A_net]
+  # Set light intensity dependent on whether it is incident or
+  # absorbed that you want the variables on
+  if (usealpha_Q) {
+    data$Q_abs = data[, varnames$PPFD] * alpha_Q
+  } else {
+    data$Q_abs = data[, varnames$PPFD]
+  }
+  # Create empty list for outputs
+  output = list(NULL)
+  # Fit AQ response model using nlsLM - this function is more
+  # robust (i.e. successful) than regular nls
+  output[[1]] = nlsLM(
+    data = data, A_net ~ aq_response(k_sat,
+      phi_J,
+      Q_abs = data$Q_abs,
+      theta_J
+    ) - Rd,
+    # Attempt to estimate starting parameters
+    start = list(
+      k_sat = max(data$A_net),
+      phi_J = coef(lm(
+        A_net ~ Q_abs,
+        data[data$Q_abs <
+          300, ]
+      ))[2],
+      theta_J = 0.85,
+      Rd = -coef(lm(
+        A_net ~ Q_abs,
+        data[data$Q_abs <
+          300, ]
+      ))[1]
+    ),
+    # Set lower limits
+    lower = c(
+      min(data$A_net),
+      0,
+      0,
+      0
+    ),
+    # set upper limits
+    upper = c(
+      10 * max(abs(data$A_net)),
+      0.5,
+      1,
+      max(abs(data$A_net))
+    ),
+    # set max iterations for curve fitting
+    control = nls.lm.control(maxiter = 100)
+  )
+  # Prepare output dataframe and extract coefficients
+  fitted_pars = NULL
+  fitted_pars$A_sat = coef(output[[1]])[1]
+  fitted_pars$phi_J = coef(output[[1]])[2]
+  fitted_pars$theta_J = coef(output[[1]])[3]
+  fitted_pars$Rd = coef(output[[1]])[4]
+  fitted_pars$LCP = ((coef(output[[1]])[4]) *
+    (coef(output[[1]])[4] * coef(output[[1]])[3] -
+      coef(output[[1]])[1]) /
+    (coef(output[[1]])[2] * (coef(output[[1]])[4] -
+      coef(output[[1]])[1])))
+  fitted_pars$resid_SSs = sum(resid(output[[1]])^2)
+  # Add fitted parameters to output
+  output[[2]] = as.data.frame(do.call("cbind", fitted_pars))
+  # Create graph
+  output[[3]] = ggplot(data, aes(x = Q_abs, y = A_net)) +
+    # Add axis labels
+    labs(
+      x = expression("Irradiance (" * mu * mol ~ m^{
+        -2
+      } ~ s^
+        {
+          -1
+        } * ")"),
+      y = expression(A[net] ~ "(" * mu * mol ~ m^{
+        -2
+      } ~ s^
+        {
+          -1
+        } * ")")
+    ) +
+    # Add title
+    ggtitle(label = title) +
+    # Add fitted smoothing function
+    geom_smooth(
+      method = "lm", aes(x = Q_abs, y = A_net),
+      show.legend = TRUE,
+      formula = y ~ I(aq_response(
+        k_sat = output[[2]]$A_sat[1],
+        phi_J = output[[2]]$phi_J[1],
+        Q_abs = x,
+        theta_J = output[[2]]$theta_J[1]
+      ) -
+        output[[2]]$Rd[1]),
+      linewidth = 2
+    ) +
+    # Add points
+    geom_point(size = 2) +
+    # Use clean theme
+    theme_bw()
+  # Name outputs
+  names(output) = c("Model", "Parameters", "Graph")
+  # Return list of outputs
+  return(output)
+}

data/R/fit_g_mc_variableJ.R

@@ -0,0 +1,151 @@
+#' Fitting mesophyll conductance with the variable J method
+#'
+#' @param data Dataframe
+#' @param varnames Variable names to fit g_mc. varnames = list(A_net = "A_net",
+#' J_etr = "J_etr", C_i = "C_i", PPFD = "PPFD", phi_PSII = "phi_PSII"), where
+#' A_net is net CO2 assimilation in umol m-2 s-1, J_etr is linear electron
+#' transport flux in umol m-2 s-1, C_i is intercellular CO2 concentration in
+#' umol mol-1, PPFD is incident irradiance in umol m-2 s-1, phi_PSII is
+#' the operating efficiency of photosystem II.
+#' @param usealpha_Q Recalculate electron transport with new absorbance value?
+#' @param alpha_Q Absorbance of photosynthetically active radiation
+#' @param beta_Q Partitioning of absorbed light energy between PSI and PSII
+#' @param gamma_star Photorespiratory CO2 compensation point in umol mol-1
+#' @param R_d Respiration rate in umol m-2 s-1
+#' @param P Atmospheric pressure in kPa
+#'
+#' @return fit_g_mc_variableJ fits mesophyll conductance according
+#' to Harley et al. 1992. It also tests the reliability of the
+#' calculation and calculates a mean with only reliable values.
+#' Note that the output is in units of umol m-2 s-1 Pa-1.
+#'
+#' @references
+#' Harley PC, Loreto F, Di Marco G, Sharkey TD. 1992. Theoretical
+#' considerations when estimating mesophyll conductance to CO2 flux
+#' by analysis of the response of photosynthesis to CO2. Plant Physiol
+#' 98:1429 - 1436.
+#' @export
+#'
+#' @examples
+#' \donttest{
+#' # Read in your data
+#' # Note that this data is coming from data supplied by the package
+#' # hence the complicated argument in read.csv()
+#' # This dataset is a CO2 by light response curve for a single sunflower
+#' data <- read.csv(system.file("extdata", "A_Ci_Q_data_1.csv",
+#'   package = "photosynthesis"
+#' ))
+#'
+#' # Note: there will be issues here if the alpha value used
+#' # for calculating ETR is off, if gamma_star is incorrect,
+#' # if R_d is incorrect.
+#' data <- fit_g_mc_variableJ(data,
+#'   varnames = list(
+#'     A_net = "A",
+#'     J_etr = "ETR",
+#'     C_i = "Ci",
+#'     PPFD = "Qin",
+#'     phi_PSII = "PhiPS2"
+#'   ),
+#'   gamma_star = 46,
+#'   R_d = 0.153,
+#'   usealpha_Q = TRUE,
+#'   alpha_Q = 0.84,
+#'   beta_Q = 0.5,
+#'   P = 84
+#' )
+#'
+#' # Note that many g_mc values from this method can be unreliable
+#' ggplot(data, aes(x = CO2_s, y = g_mc, colour = reliable)) +
+#'   labs(
+#'     x = expression(CO[2] ~ "(" * mu * mol ~ mol^
+#'       {
+#'         -1
+#'       } * ")"),
+#'     y = expression(g[m] ~ "(mol" ~ m^{
+#'       -2
+#'     } ~ s^{
+#'       -1
+#'     } ~ Pa^
+#'       {
+#'         -1
+#'       } * ")")
+#'   ) +
+#'   geom_point(size = 2) +
+#'   theme_bw() +
+#'   theme(legend.position = "bottom")
+#'
+#' # Plot QAQC graph according to Harley et al. 1992
+#' ggplot(data, aes(x = CO2_s, y = dCcdA, colour = reliable)) +
+#'   labs(
+#'     x = expression(CO[2] ~ "(" * mu * mol ~ mol^
+#'       {
+#'         -1
+#'       } * ")"),
+#'     y = expression(delta * C[chl] * "/" * delta * A)
+#'   ) +
+#'   geom_hline(yintercept = 10) +
+#'   geom_point(size = 2) +
+#'   theme_bw() +
+#'   theme(legend.position = "bottom")
+#' }
+fit_g_mc_variableJ <- function(data,
+                               varnames = list(
+                                 A_net = "A_net",
+                                 J_etr = "J_etr",
+                                 C_i = "C_i",
+                                 PPFD = "PPFD",
+                                 phi_PSII = "phi_PSII"
+                               ),
+                               usealpha_Q = FALSE,
+                               alpha_Q = 0.84,
+                               beta_Q = 0.5,
+                               gamma_star,
+                               R_d,
+                               P = 100) {
+  # Set variable names in data if different from defaults
+  data$A_net <- data[, varnames$A_net]
+  data$J_etr <- data[, varnames$J_etr]
+  data$C_i <- data[, varnames$C_i] # In umol / mol
+  # If assigning alpha_Q, re-calculate J_etr, otherwise use J_etr
+  if (usealpha_Q) {
+    data$PPFD <- data[, varnames$PPFD]
+    data$phi_PSII <- data[, varnames$phi_PSII]
+    data$J_etr <- data$PPFD * alpha_Q * beta_Q * data$phi_PSII
+  } else {
+    data$J_etr <- data[, varnames$J_etr]
+  }
+  # Convert C_i and gamma_star into Pa
+  data$C_i_pa <- data$C_i / 1000000 * P * 1000
+  gamma_star <- gamma_star / 1000000 * P * 1000
+  # Calculate g_mc according to Harley et al. 1992
+  data$g_mc <- data$A_net /
+    (data$C_i_pa - (gamma_star * (data$J_etr + 8 * (data$A_net + R_d)) /
+      (data$J_etr - 4 * (data$A_net + R_d))))
+
+  # According to Harley et al. 1992, if dCc/dA_net is too great
+  # g_mc is super sensitive to small errors, while if dCc/dA is too
+  # small, the results can be "unbelieveable". They suggested a
+  # range of 10 to 50 being acceptable, so the calculations for
+  # reliability are based on those. Please note that they may
+  # since have been mistaken, so this range is more of a guide
+  # rather than a hard and fast rule.
+  data$dCcdA <- 12 * gamma_star * data$J_etr /
+    (data$J_etr - 4 * (data$A_net + R_d))^2
+
+  data$reliable_g_mc <- rep(TRUE, length(data$g_mc))
+  # for loop to add TRUE/FALSE values to the reliability of the
+  # g_mc measurements. Cutoffs based on Harley et al. 1992.
+  for (i in 1:length(data$reliable_g_mc)) {
+    if (data$dCcdA[i] < 10) {
+      data$reliable[i] <- FALSE
+    }
+    if (data$dCcdA[i] > 50) {
+      data$reliable[i] <- FALSE
+    }
+  }
+  # Calculate the mean of reliable g_mc values
+  data$mean_g_mc_reliable <- mean(data[data$reliable == TRUE, ]$g_mc)
+  # return allows the output to be stored in the global environment
+  return(data)
+}

data/R/fit_gs_model.R

@@ -0,0 +1,346 @@
+#' Fitting stomatal conductance models
+#'
+#' @param data Dataframe
+#' @param varnames Variable names
+#'
+#' For the Ball-Berry model: varnames = list(A_net = "A_net", C_air = "C_air",
+#' g_sw = "g_sw", RH = "RH") where A_net is net CO2 assimilation, C_air is CO2
+#' concentration at the leaf surface in umol mol-1, g_sw is stomatal
+#' conductance to H2O, and RH is relative humidity as a proportion.
+#'
+#' For the Leuning model: varnames = list(A_net = "A_net", C_air = "C_air",
+#' g_sw = "g_sw", VPD = "VPD") where A_net is net CO2 assimilation, C_air is
+#' CO2 concentration at the leaf surface in umol mol-1, g_sw is stomatal
+#' conductance to H2O, and VPD is leaf to air vapor pressure deficit in kPa.
+#'
+#' For the Medlyn et al. 2011 models: varnames = list(A_net = "A_net",
+#' C_air = "C_air", g_sw = "g_sw", VPD = "VPD") where A_net is net CO2
+#' assimilation, C_air is CO2 concentration at the leaf surface in umol mol-1,
+#' g_sw is stomatal conductance to H2O, and VPD is leaf to air vapor pressure
+#' deficit in kPa.
+#' @param model Which model(s) to fit? Defaults to all models. Available
+#' options are "BallBerry", "Leuning", "Medlyn_partial", and "Medlyn_full",
+#' from Ball et al. (1987), Leuning (1995), and Medlyn et al. (2011).
+#' @param D0 Vapor pressure sensitivity of stomata (Leuning 1995)
+#' @param ... Arguments to pass on to the nlsLM() function for the Medlyn
+#' models.
+#'
+#' @references
+#'
+#' Ball JT, Woodrow IE, Berry JA. 1987. A model predicting stomatal
+#' conductance and its contribution to the control of photosynthesis
+#' under different environmental conditions, in Progress in
+#' Photosynthesis Research, Proceedings of the VII International
+#' Congress on Photosynthesis, vol. 4, edited by I. Biggins, pp.
+#' 221–224, Martinus Nijhoff, Dordrecht, Netherlands.
+#'
+#' Leuning R. 1995. A critical appraisal of a coupled stomatal-
+#' photosynthesis model for C3 plants. Plant Cell Environ 18:339-357
+#'
+#' Medlyn BE, Duursma RA, Eamus D, Ellsworth DS, Prentice IC, Barton
+#' CVM, Crous KY, Angelis PD, Freeman M, Wingate L. 2011. Reconciling
+#' the optimal and empirical approaches to modeling stomatal
+#' conductance. Glob Chang Biol 17:2134-2144
+#'
+#' @importFrom minpack.lm nlsLM
+#'
+#' @return fit_gs_model fits one or more stomatal conductance models to the
+#' data. The top level of the output list is named after the fitted model,
+#' while the second level contains the Model, Parameters, and Graph, in that
+#' order.
+#' @export
+#'
+#' @examples
+#' \donttest{
+#' # Read in your data
+#' # Note that this data is coming from data supplied by the package
+#' # hence the complicated argument in read.csv()
+#' # This dataset is a CO2 by light response curve for a single sunflower
+#' data <- read.csv(system.file("extdata", "A_Ci_Q_data_1.csv",
+#'   package = "photosynthesis"
+#' ))
+#'
+#' # Convert RH to a proportion
+#' data$RH <- data$RHcham / 100
+#'
+#' # Fit stomatal conductance models
+#' # Can specify a single model, or all as below
+#' fits <- fit_gs_model(
+#'   data = data,
+#'   varnames = list(
+#'     A_net = "A",
+#'     C_air = "Ca",
+#'     g_sw = "gsw",
+#'     RH = "RH",
+#'     VPD = "VPDleaf"
+#'   ),
+#'   model = c(
+#'     "BallBerry",
+#'     "Leuning",
+#'     "Medlyn_partial",
+#'     "Medlyn_full"
+#'   ),
+#'   D0 = 3
+#' )
+#'
+#' # Look at BallBerry model summary:
+#' summary(fits[["BallBerry"]][["Model"]])
+#'
+#' # Look at BallBerry parameters
+#' fits[["BallBerry"]][["Parameters"]]
+#'
+#' # Look at BallBerry plot
+#' fits[["BallBerry"]][["Graph"]]
+#'
+#' # Fit many g_sw models
+#' # Set your grouping variable
+#' # Here we are grouping by Qin and individual
+#' data$Q_2 <- as.factor((round(data$Qin, digits = 0)))
+#'
+#' fits <- fit_many(data,
+#'   varnames = list(
+#'     A_net = "A",
+#'     C_air = "Ca",
+#'     g_sw = "gsw",
+#'     RH = "RH",
+#'     VPD = "VPDleaf"
+#'   ),
+#'   funct = fit_gs_model,
+#'   group = "Q_2"
+#' )
+#'
+#' # Look at the Medlyn_partial outputs at 750 PAR
+#' # Model summary
+#' summary(fits[["750"]][["Medlyn_partial"]][["Model"]])
+#'
+#' # Model parameters
+#' fits[["750"]][["Medlyn_partial"]][["Parameters"]]
+#'
+#' # Graph
+#' fits[["750"]][["Medlyn_partial"]][["Graph"]]
+#'
+#' # Compile parameter outputs for BallBerry model
+#' # Note that it's the first element for each PAR value
+#' # First compile list of BallBerry fits
+#' bbmods <- compile_data(
+#'   data = fits,
+#'   output_type = "list",
+#'   list_element = 1
+#' )
+#' # Now compile the parameters (2nd element) into a dataframe
+#' bbpars <- compile_data(
+#'   data = bbmods,
+#'   output_type = "dataframe",
+#'   list_element = 2
+#' )
+#'
+#' # Convert group variable back to numeric
+#' bbpars$ID <- as.numeric(bbpars$ID)
+#'
+#' # Take quick look at light response of intercept parameters
+#' plot(g0 ~ ID, bbpars)
+#'
+#' # Compile graphs
+#' graphs <- compile_data(
+#'   data = bbmods,
+#'   output_type = "list",
+#'   list_element = 3
+#' )
+#'
+#' # Look at 3rd graph
+#' graphs[[3]]
+#' }
+fit_gs_model <- function(data, varnames = list(
+                           A_net = "A_net",
+                           C_air = "C_air",
+                           g_sw = "g_sw",
+                           RH = "RH",
+                           VPD = "VPD"
+                         ),
+                         model = c(
+                           "BallBerry",
+                           "Leuning",
+                           "Medlyn_partial",
+                           "Medlyn_full"
+                         ),
+                         D0 = 3,
+                         ...) {
+  # Check: are the models available?
+  if (TRUE %in% c(!model %in% c(
+    "BallBerry",
+    "Leuning",
+    "Medlyn_partial",
+    "Medlyn_full"
+  ))) {
+    stop("Specified model is not available. Current supported models are
+          BallBerry, Leuning, Medlyn_partial, and Medlyn_full.")
+  }
+  # Locally bind variables - avoids notes on check package
+  A_net <- NULL
+  C_air <- NULL
+  g_sw <- NULL
+  RH <- NULL
+  VPD <- NULL
+  # Assign variable names
+  data$A_net <- data[, varnames$A_net]
+  data$C_air <- data[, varnames$C_air]
+  data$g_sw <- data[, varnames$g_sw]
+  data$RH <- data[, varnames$RH]
+  data$VPD <- data[, varnames$VPD]
+  # Create empty list for number of output elements
+  models <- vector("list", length(model))
+  names(models) <- model
+  # BallBerry Model
+  if ("BallBerry" %in% model) {
+    models[["BallBerry"]] <- vector("list", 3)
+    # Assign linear regression model to element 1
+    models[["BallBerry"]][[1]] <-
+      lm(
+        data = data,
+        g_sw ~ gs_mod_ballberry(
+          A_net = A_net,
+          C_air = C_air,
+          RH = RH
+        )
+      )
+    # Extract coefficients
+    g0 <- coef(models[["BallBerry"]][[1]])[[1]]
+    g1 <- coef(models[["BallBerry"]][[1]])[[2]]
+    # Create list element of coefficients
+    models[["BallBerry"]][[2]] <- as.data.frame(cbind(g0, g1))
+    # Assign graph to element 3
+    models[["BallBerry"]][[3]] <- ggplot(
+      data,
+      aes(x = I(A_net * C_air * RH), y = g_sw)
+    ) +
+      geom_smooth(method = "lm", formula = y ~ x) +
+      geom_point() +
+      theme_bw()
+    # Assign names to list
+    names(models[["BallBerry"]]) <- c("Model", "Parameters", "Graph")
+  }
+  if ("Leuning" %in% model) {
+    models[["Leuning"]] <- vector("list", 3)
+    # Assign regression model to element 1
+    models[["Leuning"]][[1]] <- lm(
+      data = data,
+      g_sw ~ gs_mod_leuning(
+        A_net = A_net,
+        C_air = C_air,
+        D0 = D0,
+        VPD = VPD
+      )
+    )
+    # Extract coefficients
+    g0 <- coef(models[["Leuning"]][[1]])[[1]]
+    g1 <- coef(models[["Leuning"]][[1]])[[2]]
+    # Assign coefficients to element 2
+    models[["Leuning"]][[2]] <- as.data.frame(cbind(g0, g1))
+    # Assign graph to element 3
+    models[["Leuning"]][[3]] <- ggplot(
+      data,
+      aes(
+        x = I(A_net /
+          (C_air * (1 + VPD * D0))),
+        y = g_sw
+      )
+    ) +
+      geom_smooth(method = "lm", formula = y ~ x) +
+      geom_point() +
+      theme_bw()
+    # Assign names to list elements
+    names(models[["Leuning"]]) <- c("Model", "Parameters", "Graph")
+  }
+  if ("Medlyn_partial" %in% model) {
+    models[["Medlyn_partial"]] <- vector("list", 3)
+    # Fit model, assign to element 1
+    try(models[["Medlyn_partial"]][[1]] <- nlsLM(
+      data = data,
+      g_sw ~ gs_mod_opti(
+        A_net = A_net,
+        C_air = C_air,
+        VPD = VPD,
+        g0,
+        g1
+      ),
+      start = list(
+        g0 = 0,
+        g1 = 1
+      ),
+      control = nls.control(maxiter = 1000),
+      ...
+    ))
+    # Extract coefficients and make dataframe
+    g0 <- coef(models[["Medlyn_partial"]][[1]])[[1]]
+    g1 <- coef(models[["Medlyn_partial"]][[1]])[[2]]
+
+    # Assign coefficients to element 2
+    if (is.null(models[["Medlyn_partial"]][[1]]) == TRUE) {
+      models[["Medlyn_partial"]][[2]] <- data.frame(cbind("NA", "NA"))
+      colnames(models[["Medlyn_partial"]][[2]]) <- c("g0", "g1")
+    } else {
+      models[["Medlyn_partial"]][[2]] <- as.data.frame(cbind(g0, g1))
+    }
+    # Create graph, assign to element 3
+    models[["Medlyn_partial"]][[3]] <- ggplot(
+      data,
+      aes(x = I(1.6 / (sqrt(VPD)) *
+        (A_net / C_air) + 1.6 *
+          (A_net / C_air)), y = g_sw)
+    ) +
+      geom_smooth(method = "lm", formula = y ~ x) +
+      geom_point() +
+      theme_bw()
+    # Assign names to list elements
+    names(models[["Medlyn_partial"]]) <- c("Model", "Parameters", "Graph")
+  }
+  if ("Medlyn_full" %in% model) {
+    models[["Medlyn_full"]] <- vector("list", 3)
+    # Fit model, assign to element 1
+    try(models[["Medlyn_full"]][[1]] <- nlsLM(
+      data = data,
+      g_sw ~ gs_mod_optifull(
+        A_net = A_net,
+        C_air = C_air,
+        VPD = VPD,
+        g0,
+        g1,
+        gk
+      ),
+      start = list(
+        g0 = 0,
+        g1 = 1,
+        gk = 1
+      ),
+      control = nls.control(maxiter = 1000),
+      ...
+    ))
+    # Extract coefficients and make dataframe
+    g0 <- coef(models[["Medlyn_full"]][[1]])[[1]]
+    g1 <- coef(models[["Medlyn_full"]][[1]])[[2]]
+    gk <- coef(models[["Medlyn_full"]][[1]])[[3]]
+    # Assign coefficients to element 2
+    if (is.null(models[["Medlyn_full"]][[1]]) == TRUE) {
+      models[["Medlyn_full"]][[2]] <- data.frame(cbind("NA", "NA", "NA"))
+      colnames(models[["Medlyn_full"]][[2]]) <- c("g0", "g1", "gk")
+    } else {
+      models[["Medlyn_full"]][[2]] <- as.data.frame(cbind(g0, g1, gk))
+    }
+    # Create graph, assign to element 3
+    models[["Medlyn_full"]][[3]] <- ggplot(
+      data,
+      aes(x = I(1.6 / ((VPD)^(1 - gk)) *
+        (A_net / C_air) + 1.6 *
+          (A_net / C_air)), y = g_sw)
+    ) +
+      geom_smooth(method = "lm", formula = y ~ x) +
+      geom_point() +
+      theme_bw()
+    # Assign names to list elements
+    names(models[["Medlyn_full"]]) <- c("Model", "Parameters", "Graph")
+  }
+  # Add new models here, and make sure their names are available in the model
+  # argument at the top.
+  # Return list of model outputs
+  return(models)
+}

data/R/fit_hyrda_vuln_curve.R

@@ -0,0 +1,318 @@
+#' Fitting hydraulic vulnerability curves
+#'
+#' @param data Dataframe
+#' @param varnames List of variable names. varnames = list(psi = "psi",
+#' PLC = "PLC") where psi is water potential in MPa, and PLC is percent
+#' loss conductivity.
+#' @param title Title for the output graph
+#' @param start_weibull starting values for the nls fitting routine
+#' for the Weibull curve
+#'
+#' @return fit_hydra_vuln_curve fits a sigmoidal function (Pammenter & Van der
+#' Willigen, 1998) linearized according to Ogle et al. (2009). Output is a list
+#' containing the sigmoidal model in element 1 and Weibull model in element 4,
+#' the fit parameters with 95% confidence interval for both models are in
+#' element 2, and hydraulic parameters in element 3 (including P25, P50, P88,
+#' P95, S50, Pe, Pmax, DSI). Px (25 to 95): water potential at which x% of
+#' conductivity is lost. S50: slope at 50% loss of conductivity. Pe: air
+#' entry point. Pmax: hydraulic failure threshold. DSI: drought stress interval.
+#' Element 5 is a graph showing the fit, P50, Pe, and Pmax.
+#'
+#' @references
+#' Ogle K, Barber JJ, Willson C, Thompson B. 2009. Hierarchical statistical
+#' modeling of xylem vulnerability to cavitation. New Phytologist 182:541-554
+#'
+#' Pammenter NW, Van der Willigen CV. 1998. A mathematical and statistical
+#' analysis of the curves illustrating vulnerability of xylem to cavitation.
+#' Tree Physiology 18:589-593
+#'
+#' @importFrom dplyr bind_rows
+#' @importFrom ggplot2 ggplot
+#' @importFrom ggplot2 aes
+#' @importFrom ggplot2 annotate
+#' @importFrom ggplot2 element_blank
+#' @importFrom ggplot2 labs
+#' @importFrom ggplot2 ggtitle
+#' @importFrom ggplot2 geom_smooth
+#' @importFrom ggplot2 geom_point
+#' @importFrom ggplot2 geom_vline
+#' @importFrom ggplot2 scale_colour_manual
+#' @importFrom ggplot2 theme
+#' @importFrom ggplot2 theme_bw
+#' @importFrom stats confint
+#' @importFrom stats deriv
+#'
+#' @export
+#' @examples
+#' \donttest{
+#' # Read in data
+#' data <- read.csv(system.file("extdata", "hydraulic_vulnerability.csv",
+#'   package = "photosynthesis"
+#' ))
+#'
+#' # Fit hydraulic vulnerability curve
+#' fit <- fit_hydra_vuln_curve(data[data$Tree == 4 & data$Plot == "Control", ],
+#'   varnames = list(
+#'     psi = "P",
+#'     PLC = "PLC"
+#'   ),
+#'   title = "Control 4"
+#' )
+#'
+#' # Return Sigmoidal model summary
+#' summary(fit[[1]])
+#'
+#' # Return Weibull model summary
+#' summary(fit[[4]])
+#'
+#' # Return model parameters with 95\% confidence intervals
+#' fit[[2]]
+#'
+#' # Return hydraulic parameters
+#' fit[[3]]
+#'
+#' # Return graph
+#' fit[[5]]
+#'
+#' # Fit many curves
+#' fits <- fit_many(
+#'   data = data,
+#'   varnames = list(
+#'     psi = "P",
+#'     PLC = "PLC"
+#'   ),
+#'   group = "Tree",
+#'   funct = fit_hydra_vuln_curve
+#' )
+#'
+#' # To select individuals from the many fits
+#' # Return model summary
+#' summary(fits[[1]][[1]]) # Returns model summary
+#'
+#' # Return sigmoidal model output
+#' fits[[1]][[2]]
+#'
+#' # Return hydraulic parameters
+#' fits[[1]][[3]]
+#'
+#' # Return graph
+#' fits[[1]][[5]]
+#'
+#' # Compile parameter outputs
+#' pars <- compile_data(
+#'   data = fits,
+#'   output_type = "dataframe",
+#'   list_element = 3
+#' )
+#'
+#' # Compile graphs
+#' graphs <- compile_data(
+#'   data = fits,
+#'   output_type = "list",
+#'   list_element = 5
+#' )
+#' }
+fit_hydra_vuln_curve <- function(data,
+                                 varnames = list(
+                                   psi = "psi",
+                                   PLC = "PLC"
+                                 ),
+                                 start_weibull = list(
+                                   a = 2,
+                                   b = 2
+                                 ),
+                                 title = NULL) {
+  # Locally bind variables - avoids notes on check package
+  psi <- NULL
+  PLC <- NULL
+  # Assign variable names
+  data$psi <- data[, varnames$psi]
+  data$PLC <- data[, varnames$PLC]
+  # Prepare y variable for sigmoidal function
+  data$H_log <- log(100 / data$PLC - 1)
+  # Prepare y variable for Weibull function
+  data$K.Kmax <- (1 - data$PLC / 100)
+  # Generate empty list for data outputs
+  fit_out <- list(NULL)
+  # Starting with the sigmoidal model
+  # Fit model, remove any infinite values (e.g. at P = 0)
+  fit_out[[1]] <- lm(H_log ~ psi, data[data$H_log < Inf, ])
+  # Extract model parameter values
+  fit_out[[2]] <- data.frame(c(coef(fit_out[[1]])[1], coef(fit_out[[1]])[2]))
+  # Note that in model, the intercept is - a * b
+  fit_out[[2]][1, ] <- fit_out[[2]][1, ] / -fit_out[[2]][2, ]
+  # Assign row names
+  rownames(fit_out[[2]]) <- c("b", "a")
+  # Assign parameter names
+  fit_out[[2]]$Parameter <- rownames(fit_out[[2]])
+  # Assign curve name
+  fit_out[[2]]$Curve <- "Sigmoidal"
+  # Assign column names
+  colnames(fit_out[[2]]) <- c(
+    "Value",
+    "Parameter", "Curve"
+  )
+  # Create dataframe for calculated parameters
+  fit_out[[3]] <- as.data.frame(rbind(1:8))
+  # Add column names
+  colnames(fit_out[[3]]) <- c(
+    "P25", "P50", "P88", "P95",
+    "S50", "Pe", "Pmax", "DSI"
+  )
+  # Assign a and b values to minimize typing
+  a <- fit_out[[2]]$Value[2]
+  b <- fit_out[[2]]$Value[1]
+  # Calculate hydraulic parameters
+  fit_out[[3]]$P25 <- log(1 / (0.25) - 1) / (a) + b
+  fit_out[[3]]$P50 <- log(1 / (0.5) - 1) / (a) + b
+  fit_out[[3]]$P88 <- log(1 / (0.88) - 1) / (a) + b
+  fit_out[[3]]$P95 <- log(1 / (0.95) - 1) / (a) + b
+  # To get slope, we need to take derivative of model and calculate at P50
+  XX <- fit_out[[3]]$P50
+  dWpsi <- deriv(~ 100 / (1 + exp(a * (XX - b))), "XX")
+  derivSoln <- eval(dWpsi)
+  # This extracts the slope at P50
+  fit_out[[3]]$S50 <- as.numeric(attributes(derivSoln)$gradient)
+  # Next calculate the air entry point
+  yint <- 50 - (fit_out[[3]]$S50 * fit_out[[3]]$P50)
+  fit_out[[3]]$Pe <- -yint / fit_out[[3]]$S50
+  # Calculate the hydraulic failure threshold
+  fit_out[[3]]$Pmax <- (100 - yint) / fit_out[[3]]$S50
+  # Calculate the drought stress interval
+  fit_out[[3]]$DSI <- fit_out[[3]]$Pmax - fit_out[[3]]$Pe
+  # Add curve name
+  fit_out[[3]]$Curve <- "Sigmoidal"
+  # Remove a and b values
+  remove(a)
+  remove(b)
+  # Moving on to Weibull model
+  fit_out[[4]] <- nlsLM(
+    data = data,
+    K.Kmax ~ exp(-((psi / a)^b)),
+    start = start_weibull
+  )
+  # Extract model parameter values
+  fit_out[[5]] <- data.frame(c(coef(fit_out[[4]])[2], coef(fit_out[[4]])[1]))
+  # Assign parameter names
+  fit_out[[5]]$Parameter <- rownames(fit_out[[5]])
+  # Assign curve name
+  fit_out[[5]]$Curve <- "Weibull"
+  # Assign column names
+  colnames(fit_out[[5]]) <- c(
+    "Value",
+    "Parameter", "Curve"
+  )
+  # Merge model parameters to reduce size of list
+  fit_out[[2]] <- bind_rows(fit_out[[2]], fit_out[[5]])
+  # Create dataframe for calculated parameters
+  fit_out[[5]] <- as.data.frame(rbind(1:8))
+  # Add column names
+  colnames(fit_out[[5]]) <- c(
+    "P25", "P50", "P88", "P95",
+    "S50", "Pe", "Pmax", "DSI"
+  )
+  # Assign a and b values to minimize typing
+  a <- fit_out[[2]]$Value[4]
+  b <- fit_out[[2]]$Value[3]
+  # Calculate hydraulic parameters
+  fit_out[[5]]$P25 <- (-log(1 - 25 / 100))^(1 / b) * a
+  fit_out[[5]]$P50 <- (-log(1 - 50 / 100))^(1 / b) * a
+  fit_out[[5]]$P88 <- (-log(1 - 88 / 100))^(1 / b) * a
+  fit_out[[5]]$P95 <- (-log(1 - 95 / 100))^(1 / b) * a
+  # To get slope, we need to take derivative of model and calculate at P50
+  dWpsi <- deriv(~ (1 - exp(-(XX / a)^b)) * 100, "XX")
+  XX <- fit_out[[5]]$P50
+  derivSoln <- eval(dWpsi)
+  # This extracts the slope at P50
+  fit_out[[5]]$S50 <- as.numeric(attributes(derivSoln)$gradient)
+  # Next calculate the air entry point
+  yint <- 50 - (fit_out[[5]]$S50 * fit_out[[5]]$P50)
+  fit_out[[5]]$Pe <- -yint / fit_out[[5]]$S50
+  # Calculate the hydraulic failure threshold
+  fit_out[[5]]$Pmax <- (100 - yint) / fit_out[[5]]$S50
+  # Calculate the drought stress interval
+  fit_out[[5]]$DSI <- fit_out[[5]]$Pmax - fit_out[[5]]$Pe
+  # Add curve name
+  fit_out[[5]]$Curve <- "Weibull"
+  # Combine output variables to reduce size of list
+  fit_out[[3]] <- rbind(fit_out[[3]], fit_out[[5]])
+  # Generates plot of hydraulic vulnerability curve
+  fit_out[[5]] <- ggplot(data, aes(x = psi, y = PLC)) +
+    ggtitle(label = title) +
+    geom_vline(
+      xintercept = fit_out[[3]]$P50[1],
+      linewidth = 2,
+      colour = "Blue"
+    ) +
+    geom_vline(
+      xintercept = fit_out[[3]]$Pe[1],
+      linewidth = 2,
+      colour = "Blue"
+    ) +
+    geom_vline(
+      xintercept = fit_out[[3]]$Pmax[1],
+      linewidth = 2,
+      colour = "Blue"
+    ) +
+    geom_vline(
+      xintercept = fit_out[[3]]$P50[2],
+      linewidth = 2,
+      colour = "Orange",
+      linetype = "dashed"
+    ) +
+    geom_vline(
+      xintercept = fit_out[[3]]$Pe[2],
+      linewidth = 2,
+      colour = "Orange",
+      linetype = "dashed"
+    ) +
+    geom_vline(
+      xintercept = fit_out[[3]]$Pmax[2],
+      linewidth = 2,
+      colour = "Orange",
+      linetype = "dashed"
+    ) +
+    geom_smooth(
+      method = "lm", aes(
+        x = psi, y = PLC,
+        colour = "Blue"
+      ), show.legend = TRUE,
+      formula = y ~ I(100 /
+        (1 + exp(fit_out[[2]]$Value[2] *
+          (x - fit_out[[2]]$Value[1])))),
+      linewidth = 2
+    ) +
+    geom_smooth(
+      method = "lm", aes(
+        x = psi, y = PLC,
+        colour = "DarkOrange"
+      ), show.legend = TRUE,
+      formula = y ~
+      I((1 - exp(-((x / fit_out[[2]]$Value[4])^
+        fit_out[[2]]$Value[3]))) * 100),
+      linewidth = 2
+    ) +
+    geom_point(size = 2, aes(colour = "Black")) +
+    labs(y = "PLC (%)", x = "Water Potential (-MPa)") +
+    scale_colour_manual(
+      values = c("Black", "Blue", "Orange"),
+      labels = c("Data", "Sigmoidal", "Weibull")
+    ) +
+    annotate("text",
+      label = "Left to Right:
+             Pe > P50 > Pmax",
+      x = 0.5, y = 75
+    ) +
+    theme_bw() +
+    theme(
+      legend.position = "bottom",
+      legend.title = element_blank()
+    )
+  # Assign names to elements in the output list
+  names(fit_out) <- c(
+    "Sig_Model", "Model_Parameters", "Model_Px Values",
+    "Wei_Model", "Graph"
+  )
+  # Return output list
+  return(fit_out)
+}

data/R/fit_many.R

@@ -0,0 +1,106 @@
+#' Fitting many functions across groups
+#'
+#' @description
+#' `r lifecycle::badge("deprecated")`
+#' 
+#' We are no longer updating this function. Please use generic methods like \code{\link[purrr]{map}} instead. See `vignette("light-response")` for an example.
+#' 
+#' @param data Dataframe
+#' @param funct Function to fit
+#' @param group Grouping variables
+#' @param progress Flag. Show progress bar?
+#' @param ... Arguments for the function to fit. Use ?functionname
+#' to read the help file on available arguments for a given function.
+#'
+#' @return fit_many fits a function across every instance of
+#' a grouping variable.
+#' @importFrom utils setTxtProgressBar
+#' @importFrom utils txtProgressBar
+#' @export
+#'
+#' @examples
+#' \donttest{
+#' # Read in your data
+#' # Note that this data is coming from data supplied by the package
+#' # hence the complicated argument in read.csv()
+#' # This dataset is a CO2 by light response curve for a single sunflower
+#' data = read.csv(system.file("extdata", "A_Ci_Q_data_1.csv",
+#'   package = "photosynthesis"
+#' ))
+#'
+#' # Define a grouping factor based on light intensity to split the ACi
+#' # curves
+#' data$Q_2 = as.factor((round(data$Qin, digits = 0)))
+#'
+#' # Convert leaf temperature to K
+#' data$T_leaf = data$Tleaf + 273.15
+#'
+#' # Fit many curves
+#' fits = fit_many(
+#'   data = data,
+#'   varnames = list(
+#'     A_net = "A",
+#'     T_leaf = "T_leaf",
+#'     C_i = "Ci",
+#'     PPFD = "Qin"
+#'   ),
+#'   funct = fit_aci_response,
+#'   group = "Q_2"
+#' )
+#'
+#' # Print the parameters
+#' # First set of double parentheses selects an individual group value
+#' # Second set selects an element of the sublist
+#' fits[[3]][[1]]
+#'
+#' # Print the graph
+#' fits[[3]][[2]]
+#'
+#' # Compile graphs into a list for plotting
+#' fits_graphs = compile_data(fits,
+#'   list_element = 2
+#' )
+#'
+#'
+#' # Compile parameters into dataframe for analysis
+#' fits_pars = compile_data(fits,
+#'   output_type = "dataframe",
+#'   list_element = 1
+#' )
+#' }
+#' 
+#' @md
+
+fit_many = function(
+    data,
+    funct,
+    group,
+    progress = TRUE,
+    ...
+) {
+  
+  lifecycle::deprecate_soft("2.1.3", "fit_many()")
+  
+  checkmate::assert_flag(progress)
+  
+  # Split data into list by group
+  data = split(data, data[, group])
+
+  # Create empty list by group
+  fits = list(NULL)
+
+  # Start progress bar
+  if (progress) {
+    pb = txtProgressBar(min = 0, max = length(data), style = 3)
+  }
+  
+  # Loop through list, fitting the function
+  for (i in 1:length(data)) {
+    fits[[i]] = funct(data[[i]], ...)
+    names(fits)[i] = names(data[i])
+    # Set progress bar
+    if (progress) setTxtProgressBar(pb, i)
+  }
+  # Return the list of fits
+  return(fits)
+}

data/R/fit_photosynthesis.R

@@ -0,0 +1,119 @@
+#' Fit photosynthetic models with gas-exchange data
+#' 
+#' @param .data A data frame containing plant ecophysiological data. See [required_variables()] for the variables required for each model.
+#' @param .photo_fun A character string of **photosynthesis** function to call. One of: ``r paste0(get_function_types(), collapse = ', ')``.
+#' @param .model A character string of model name to use. See [get_all_models()]. 
+#' @param .vars A list to rename variables in .data. See [required_variables()] for the accepted variable names.  
+#' @param .method A character string of the statistical method to use: 'ls' for least-squares and 'brms' for Bayesian model using [brms::brm()]. Default is 'ls'.
+#' @param ... Additional arguments passed to specific models. See specific help pages for each type of photosynthetic model:
+#' 
+#' * Light-response curves [fit_aq_response2()]
+#' * Light respiration [fit_r_light2()]
+#' 
+#' @param quiet Flag. Should messages be suppressed? Default is FALSE.
+#' @param brm_options A list of options passed to [brms::brm()] if `.method = "brms"`. Default is NULL.
+#' 
+#' @return A fitted model object
+#' 
+#' * class 'lm' or 'nls' if `method = 'ls'`
+#' * class 'brmsfit' if `method = 'brms'`
+#' 
+#' @note This function will fit models to data but several methods require post-processing to extract meaningful parameter estimates and confidence intervals. See vignettes for further explanation and examples.
+#'
+#' * Light-response curves: `vignette("light-response", package = "photosynthesis")`
+#' * Light respiration: `vignette("light-respiration", package = "photosynthesis")`
+#' 
+#' @md
+#' @export
+fit_photosynthesis = function(
+    .data,
+    .photo_fun,
+    .model = "default",
+    .vars = NULL,
+    .method = "ls",
+    ...,
+    quiet = FALSE,
+    brm_options = NULL
+) {
+  
+  checkmate::assert_data_frame(.data)
+  .photo_fun = match.arg(.photo_fun, choices = get_function_types())
+  .model = match.arg(.model, choices = c("default", get_all_models(.photo_fun)))
+  if (.model == "default") .model = get_default_model(.photo_fun)
+  .vars = substitute(.vars)
+  .method = match.arg(.method, choices = c("ls", "brms"))
+  checkmate::assert_flag(quiet)
+  checkmate::assert_list(brm_options, null.ok = TRUE)
+  
+  # Rename variables
+  if (!is.null(.vars)) {
+    .data = rename_variables(.data, .vars)
+  }
+
+  assert_required_variables(
+    .data = .data,
+    .photo_fun = .photo_fun,
+    .model = .model,
+    .method = .method,
+    quiet = quiet
+  )
+  
+  do.call(
+    glue::glue("fit_{.photo_fun}2"),
+    args = list(
+      .data = .data,
+      .model = .model,
+      .method = .method,
+      ...,
+      quiet = quiet,
+      brm_options = brm_options
+    )
+  )
+  
+}
+
+#' Rename variables in .data based on .vars
+#' @inheritParams fit_photosynthesis
+#' @noRd
+rename_variables = function(.data, .vars) {
+  
+  # I feel like there needs to be a better way to do this
+  deparse(.vars) |>
+    stringr::str_replace("^list\\(", ".data = dplyr::rename(.data, ") |>
+    str2lang() |>
+    eval()
+
+  .data
+  
+}
+
+#' Assert required variables are present in .data
+#' @noRd
+assert_required_variables = function(.data, .photo_fun, .model, .method, quiet) {
+  
+  v = required_variables(.model, quiet = TRUE)
+  missing_vars = v[!(v %in% colnames(.data))]
+  n_missing_vars = length(missing_vars)
+  if (n_missing_vars > 0) {
+    if (!quiet) {
+      message(paste0(".data is missing required variables: {", paste(missing_vars, collapse = ", "), "}"))
+      glue::glue(
+        "You may need to revise .vars argument by replacing `var_name1`, etc. with variable name in your_data:
+    
+    fit_photosynthesis(
+      .data = your_data,
+      .photo_fun = '{.photo_fun}',
+      .model = '{.model}',
+      .method = '{.method}',
+      .vars = list(
+        {args}
+      ),
+      ...
+    )\n\n", 
+    args = stringr::str_c(stringr::str_c(v, " = var_name", seq_len(n_missing_vars)), collapse = ",\n    ")
+      ) |>
+        cat()
+    }
+    stop(".data is missing variables. fit_photosynthesis() not run.")
+  }
+}

data/R/fit_r_light.R

@@ -0,0 +1,698 @@
+#' Fit models to estimate light respiration (\eqn{R_\mathrm{d}})
+#' 
+#' @description We recommend using [fit_photosynthesis()] with argument `.photo_fun = "r_light"` rather than calling this function directly.
+#' 
+#' @inheritParams fit_photosynthesis
+#' @param Q_lower Lower light intensity limit for estimating Rd using `kok_1956` and `yin_etal_2011` models.
+#' @param Q_upper Upper light intensity limit for estimating Rd using `kok_1956` and `yin_etal_2011` models
+#' @param Q_levels A numeric vector of light intensity levels (\eqn{\mu}mol / mol) for estimating \eqn{R_\mathrm{d}} from the linear region of the A-C curve using the `walker_ort_2015` model.
+#' @param C_upper Upper C (\eqn{\mu}mol / mol) limit for estimating \eqn{R_\mathrm{d}} from the linear region of the A-C curve using the `walker_ort_2015` model.
+#'
+#' @return 
+#' 
+#' * If `.method = 'ls'`: an [stats::nls()] or [stats::lm()] object.
+#' * If `.method = 'brms'`: a [brms::brmsfit()] object.
+#' 
+#' @note 
+#' 
+#' Confusingly, \eqn{R_\mathrm{d}} typically denotes respiration in the light, but you might see \eqn{R_\mathrm{day}} or \eqn{R_\mathrm{light}}.
+#' 
+#' **Models**
+#' 
+#' *Kok (1956)*
+#' 
+#' The `kok_1956` model estimates light respiration using the Kok method
+#' (Kok, 1956). The Kok method involves looking for a breakpoint in the
+#' light response of net CO2 assimilation at very low light intensities
+#' and extrapolating from data above the breakpoint to estimate light
+#' respiration as the y-intercept. Rd value should be negative,
+#' denoting an efflux of CO2.
+#'
+#' *Yin et al. (2011)*
+#' 
+#' The `yin_etal_2011` model estimates light respiration according
+#' to the Yin *et al.* (2009, 2011) modifications of the Kok
+#' method. The modification uses fluorescence data to get a
+#' better estimate of light respiration. Rd values should be negative here to 
+#' denote an efflux of CO2.
+#' 
+#' *Walker & Ort (2015)*
+#' 
+#' The `walker_ort_2015` model estimates light respiration and
+#' \eqn{\Gamma*} according to Walker & Ort (2015) using a slope-
+#' intercept regression method to find the intercept of multiple
+#' A-C curves run at multiple light intensities. The method estimates
+#' \eqn{\Gamma*} and \eqn{R_\mathrm{d}}. If estimated  \eqn{R_\mathrm{d}} is 
+#' positive this could indicate issues (i.e. leaks) in the gas exchange
+#' measurements. \eqn{\Gamma*} is in units of umol / mol and \eqn{R_\mathrm{d}}
+#' is in units of \eqn{\mu}mol m\eqn{^{-2}} s\eqn{^{-1}} of respiratory flux. 
+#' If using \eqn{C_\mathrm{i}}, the estimated value is technically \eqn{C_\mathrm{i}}*. 
+#' You need to use \eqn{C_\mathrm{c}} to get \eqn{\Gamma*} Also note, however, 
+#' that the convention in the field is to completely ignore this note.
+#'
+#'
+#' @references
+#' Kok B. 1956. On the inhibition of photosynthesis by intense light.
+#' Biochimica et Biophysica Acta 21: 234–244
+#'
+#' Walker BJ, Ort DR. 2015. Improved method for measuring the apparent
+#' CO2 photocompensation point resolves the impact of multiple internal
+#' conductances to CO2 to net gas exchange. Plant Cell Environ 38:2462-
+#' 2474
+#'
+#' Yin X, Struik PC, Romero P, Harbinson J, Evers JB, van der Putten
+#' PEL, Vos J. 2009. Using combined measurements of gas exchange and
+#' chlorophyll fluorescence to estimate parameters of a biochemical C3
+#' photosynthesis model: a critical appraisal and a new integrated
+#' approach applied to leaves in a wheat (Triticum aestivum) canopy.
+#' Plant Cell Environ 32:448-464
+#'
+#' Yin X, Sun Z, Struik PC, Gu J. 2011. Evaluating a new method to
+#' estimate the rate of leaf respiration in the light by analysis of
+#' combined gas exchange and chlorophyll fluorescence measurements.
+#' Journal of Experimental Botany 62: 3489–3499
+#'
+#' @examples
+#' \donttest{
+#' 
+#' # Walker & Ort (2015) model
+#' 
+#' library(broom)
+#' library(dplyr)
+#' library(photosynthesis)
+#' 
+#' acq_data = system.file("extdata", "A_Ci_Q_data_1.csv", package = "photosynthesis") |> 
+#'   read.csv()
+#' 
+#' fit = fit_photosynthesis(
+#'   .data = acq_data,
+#'   .photo_fun = "r_light",
+#'   .model = "walker_ort_2015",
+#'   .vars = list(.A = A, .Q = Qin, .C = Ci),
+#'   C_upper = 300,
+#'   # Irradiance levels used in experiment
+#'   Q_levels =  c(1500, 750, 375, 125, 100, 75, 50, 25),
+#' )
+#' 
+#' # The 'fit' object inherits class 'lm' and many methods can be used
+#' 
+#' ## Model summary:
+#' summary(fit)
+#' 
+#' ## Estimated parameters:
+#' coef(fit)
+#' 
+#' ## 95% confidence intervals:
+#' ## n.b. these confidence intervals are not correct because the regression is fit 
+#' ## sequentially. It ignores the underlying data and uncertainty in estimates of 
+#' ## slopes and intercepts with each A-C curve. Use '.method = "brms"' to properly 
+#' ## calculate uncertainty. 
+#' confint(fit)
+#' 
+#' ## Tidy summary table using 'broom::tidy()'
+#' tidy(fit, conf.int = TRUE, conf.level = 0.95)
+#' 
+#' ## Calculate residual sum-of-squares
+#' sum(resid(fit)^2)
+#' 
+#' # Yin et al. (2011) model
+#' 
+#' fit = fit_photosynthesis(
+#'   .data = acq_data,
+#'   .photo_fun = "r_light",
+#'   .model = "yin_etal_2011",
+#'   .vars = list(.A = A, .phiPSII = PhiPS2, .Q = Qin),
+#'   Q_lower = 20,
+#'   Q_upper = 250
+#' )
+#' 
+#' # The 'fit' object inherits class 'lm' and many methods can be used
+#' 
+#' ## Model summary:
+#' summary(fit)
+#' 
+#' ## Estimated parameters:
+#' coef(fit)
+#' 
+#' ## 95% confidence intervals:
+#' confint(fit)
+#' 
+#' ## Tidy summary table using 'broom::tidy()'
+#' tidy(fit, conf.int = TRUE, conf.level = 0.95)
+#' 
+#' ## Calculate residual sum-of-squares
+#' sum(resid(fit)^2)
+#' 
+#' # Kok (1956) model
+#' 
+#' fit = fit_photosynthesis(
+#'   .data = acq_data,
+#'   .photo_fun = "r_light",
+#'   .model = "kok_1956",
+#'   .vars = list(.A = A, .Q = Qin),
+#'   Q_lower = 20,
+#'   Q_upper = 150
+#' )
+#' 
+#' # The 'fit' object inherits class 'lm' and many methods can be used
+#' 
+#' ## Model summary:
+#' summary(fit)
+#' 
+#' ## Estimated parameters:
+#' coef(fit)
+#' 
+#' ## 95% confidence intervals:
+#' confint(fit)
+#' 
+#' ## Tidy summary table using 'broom::tidy()'
+#' tidy(fit, conf.int = TRUE, conf.level = 0.95)
+#' 
+#' ## Calculate residual sum-of-squares
+#' sum(resid(fit)^2)
+#' 
+#' }
+#' @md
+#' @rdname fit_r_light2
+#' @export
+fit_r_light2 = function(
+    .data,
+    .model = "default",
+    .method = "ls",
+    Q_lower = NA,
+    Q_upper = NA,
+    Q_levels = NULL,
+    C_upper = NA,
+    quiet = FALSE,
+    brm_options = NULL
+) {
+  
+  # Checks
+  checkmate::assert_number(
+    Q_lower, 
+    lower = 0,
+    na.ok = !(.model %in% c("kok_1956", "yin_etal_2011"))
+  )
+  checkmate::assert_number(
+    Q_upper, 
+    lower = Q_lower,
+    na.ok = !(.model %in% c("kok_1956", "yin_etal_2011"))
+  )
+  checkmate::assert_numeric(
+    Q_levels, 
+    lower = 0,
+    finite = TRUE,
+    any.missing = FALSE,
+    min.len = 2L,
+    null.ok = !(.model %in% c("default", "walker_ort_2015"))
+  )
+  checkmate::assert_number(
+    C_upper, 
+    lower = 0,
+    na.ok = !(.model %in% c("default", "walker_ort_2015"))
+  )
+  
+  # Fit model
+  fit = switch(
+    .method,
+    ls = fit_r_light2_ls(.data, .model, Q_lower = Q_lower, Q_upper = Q_upper,
+                         Q_levels = Q_levels, C_upper = C_upper),
+    brms = fit_r_light2_brms(.data, .model, Q_lower = Q_lower, Q_upper = Q_upper,
+                             Q_levels = Q_levels, C_upper = C_upper, 
+                             brm_options = brm_options)
+  )
+  
+  fit 
+  
+}
+
+#' Fit models to estimate light respiration (Rd) using least-squares methods
+#' @inheritParams fit_r_light2
+#' @noRd
+fit_r_light2_ls = function(
+    .data, 
+    .model, 
+    Q_lower, 
+    Q_upper,
+    Q_levels,
+    C_upper
+) {
+  
+  do.call(
+    glue::glue("fit_r_light2_{.model}_ls"),
+    args = list(
+      .data = .data, 
+      Q_lower = Q_lower, 
+      Q_upper = Q_upper,
+      Q_levels = Q_levels,
+      C_upper = C_upper
+    )
+  )
+  
+}
+
+#' Fit models to estimate light respiration (Rd) using Bayesian methods
+#' @inheritParams fit_r_light2
+#' @noRd
+fit_r_light2_brms = function(
+    .data, 
+    .model, 
+    Q_lower, 
+    Q_upper,
+    Q_levels,
+    C_upper,
+    brm_options
+) {
+
+  do.call(
+    glue::glue("fit_r_light2_{.model}_brms"),
+    args = list(
+      .data = .data, 
+      Q_lower = Q_lower, 
+      Q_upper = Q_upper,
+      Q_levels = Q_levels,
+      C_upper = C_upper,
+      brm_options = brm_options
+    )
+  )
+  
+}
+
+#' Fit models to estimate light respiration (Rd) with the Walker & Ort (2015) model using least-squares methods
+#' @inheritParams fit_r_light2
+#' @noRd
+fit_r_light2_walker_ort_2015_ls = function(
+    .data, 
+    Q_levels,
+    C_upper,
+    ...
+) {
+
+  .data = .data |>
+    dplyr::filter(.C <= C_upper) |>
+    dplyr::mutate(
+      # Group by Q_level
+      .Q_level = round_to_nearest(.Q, Q_levels)
+    )
+  
+  nlme::lmList(.A ~ .C | .Q_level, data = .data) |>
+    coef() |>
+    dplyr::mutate(gamma_star = -.C) %>%
+    lm(`(Intercept)` ~ gamma_star, data = .)
+  
+}
+
+#' Fit models to estimate light respiration (Rd) with the Walker & Ort (2015) model using Bayesian methods
+#' @inheritParams fit_r_light2
+#' @noRd
+fit_r_light2_walker_ort_2015_brms = function(
+    .data, 
+    Q_levels,
+    C_upper,
+    brm_options,
+    ...
+) {
+  
+  .data = .data |>
+    dplyr::filter(.C <= C_upper) |>
+    dplyr::mutate(
+      # Group by Q_level
+      .Q_level = as.factor(round_to_nearest(.Q, Q_levels))
+    )
+  
+  do.call(
+    brms::brm,
+    args = c(
+      brm_options,
+      list(
+        formula = .A ~ .C + (1 + .C|.Q_level),
+        data = .data
+      )
+    )
+  )
+  
+}
+
+#' Fit models to estimate light respiration (Rd) with the Yin *et al.* (2011) model using least-squares methods
+#' @inheritParams fit_r_light2
+#' @noRd
+fit_r_light2_yin_etal_2011_ls = function(
+    .data, 
+    Q_lower,
+    Q_upper,
+    ...
+) {
+  
+  .data |>
+    dplyr::filter(.Q >= Q_lower, .Q <= Q_upper) |>
+    dplyr::mutate(x_var = .Q * .phiPSII / 4) %>%
+    lm(.A ~ x_var, data = .)
+  
+}
+
+#' Fit models to estimate light respiration (Rd) with the Yin *et al.* (2011) model using Bayesian methods
+#' @inheritParams fit_r_light2
+#' @noRd
+fit_r_light2_yin_etal_2011_brms = function(
+    .data, 
+    Q_lower,
+    Q_upper,
+    brm_options,
+    ...
+) {
+  
+  .data = .data |>
+    dplyr::filter(.Q >= Q_lower, .Q <= Q_upper) |>
+    dplyr::mutate(x_var = .Q * .phiPSII / 4)
+  
+  do.call(
+    brms::brm,
+    args = c(
+      brm_options,
+      list(
+        formula = .A ~ x_var,
+        data = .data
+      )
+    )
+  )
+  
+}
+
+#' Fit models to estimate light respiration (Rd) with the Kok (1956) model using least-squares methods
+#' @inheritParams fit_r_light2
+#' @noRd
+fit_r_light2_kok_1956_ls = function(
+    .data, 
+    Q_lower,
+    Q_upper,
+    ...
+) {
+  
+  .data |>
+    dplyr::filter(.Q >= Q_lower, .Q <= Q_upper) %>%
+    lm(.A ~ .Q, data = .)
+  
+}
+
+#' Fit models to estimate light respiration (Rd) with the Kok (1956) model using Bayesian methods
+#' @inheritParams fit_r_light2
+#' @noRd
+fit_r_light2_kok_1956_brms = function(
+    .data, 
+    Q_lower,
+    Q_upper,
+    brm_options,
+    ...
+) {
+  
+  .data = .data |>
+    dplyr::filter(.Q >= Q_lower, .Q <= Q_upper)
+  
+  do.call(
+    brms::brm,
+    args = c(
+      brm_options,
+      list(
+        formula = .A ~ .Q,
+        data = .data
+      )
+    )
+  )
+  
+}
+
+#' Estimating light respiration
+#' 
+#' @description 
+#' `r lifecycle::badge("deprecated")`
+#' 
+#' Please use `fit_r_light2()`.
+#' 
+#' @param data Dataframe
+#' @param varnames List of variable names
+#' @param PPFD_lower Lower light intensity limit for estimating Rlight
+#' (Kok & Yin)
+#' @param PPFD_upper Upper light intensity limit for estimating Rlight
+#' (Kok & Yin)
+#'
+#' @param P Atmospheric pressure in kPa (Walker & Ort, 2015)
+#' @param C_i_threshold Threshold C_i (in umol / mol) to cut data to
+#' linear region for fitting light respiration and gamma_star
+#' (Walker & Ort, 2015)
+#'
+#' @return fit_r_light_kok estimates light respiration using the Kok method
+#' (Kok, 1956). The Kok method involves looking for a breakpoint in the
+#' light response of net CO2 assimilation at very low light intensities
+#' and extrapolating from data above the breakpoint to estimate light
+#' respiration as the y-intercept. r_light value should be negative,
+#' denoting an efflux of CO2.
+#'
+#' fit_r_light_WalkerOrt estimates light respiration and
+#' GammaStar according to Walk & Ort (2015) using a slope-
+#' intercept regression method to find the intercept of multiple
+#' ACi curves run at multiple light intensities. Output GammaStar and
+#' respiration should be negative If output respiration is positive
+#' this could indicate issues (i.e. leaks) in the gas exchange
+#' measurements. GammaStar is output in umol mol-1, and respiration
+#' is output in umol m-2 s-1 of respiratory flux. Output is a list
+#' containing the slope intercept regression model, a graph of the fit,
+#' and estimates of the coefficients. NOTE: if using C_i, the output value
+#' is technically C_istar. You need to use Cc to get GammaStar. Also note,
+#' however, that the convention in the field is to completely ignore this note.
+#'
+#' fit_r_light_yin estimates light respiration according
+#' to the Yin et al. (2009, 2011) modifications of the Kok
+#' method. The modification uses fluorescence data to get a
+#' better estimate of light respiration. Note that respiration
+#' output should be negative here to denote an efflux of CO2.
+#'
+#' @references
+#' Kok B. 1956. On the inhibition of photosynthesis by intense light.
+#' Biochimica et Biophysica Acta 21: 234–244
+#'
+#' Walker BJ, Ort DR. 2015. Improved method for measuring the apparent
+#' CO2 photocompensation point resolves the impact of multiple internal
+#' conductances to CO2 to net gas exchange. Plant Cell Environ 38:2462-
+#' 2474
+#'
+#' Yin X, Struik PC, Romero P, Harbinson J, Evers JB, van der Putten
+#' PEL, Vos J. 2009. Using combined measurements of gas exchange and
+#' chlorophyll fluorescence to estimate parameters of a biochemical C3
+#' photosynthesis model: a critical appraisal and a new integrated
+#' approach applied to leaves in a wheat (Triticum aestivum) canopy.
+#' Plant Cell Environ 32:448-464
+#'
+#' Yin X, Sun Z, Struik PC, Gu J. 2011. Evaluating a new method to
+#' estimate the rate of leaf respiration in the light by analysis of
+#' combined gas exchange and chlorophyll fluorescence measurements.
+#' Journal of Experimental Botany 62: 3489–3499
+#'
+#' @importFrom nlme lmList
+#' @importFrom stats coef
+#' @importFrom stats lm
+#'
+#' @examples
+#' \donttest{
+#' # FITTING KOK METHOD
+#' # Read in your data
+#' # Note that this data is coming from data supplied by the package
+#' # hence the complicated argument in read.csv()
+#' # This dataset is a CO2 by light response curve for a single sunflower
+#' data = read.csv(system.file("extdata", "A_Ci_Q_data_1.csv",
+#'   package = "photosynthesis"
+#' ))
+#'
+#' # Fit light respiration with Kok method
+#' r_light = fit_r_light_kok(
+#'   data = data,
+#'   varnames = list(
+#'     A_net = "A",
+#'     PPFD = "Qin"
+#'   ),
+#'   PPFD_lower = 20,
+#'   PPFD_upper = 150
+#' )
+#' # Return r_light
+#' r_light
+#'
+#' # FITTING WALKER-ORT METHOD
+#' # Read in your data
+#' # Note that this data is coming from data supplied by the package
+#' # hence the complicated argument in read.csv()
+#' # This dataset is a CO2 by light response curve for a single sunflower
+#' data = read.csv(system.file("extdata", "A_Ci_Q_data_1.csv",
+#'   package = "photosynthesis"
+#' ))
+#'
+#' # Fit the Walker-Ort method for GammaStar and light respiration
+#' walker_ort = fit_r_light_WalkerOrt(data,
+#'   varnames = list(
+#'     A_net = "A",
+#'     C_i = "Ci",
+#'     PPFD = "Qin"
+#'   )
+#' )
+#' # Extract model
+#' summary(walker_ort[[1]])
+#'
+#' # View graph
+#' walker_ort[[2]]
+#'
+#' # View coefficients
+#' walker_ort[[3]]
+#'
+#' # FITTING THE YIN METHOD
+#' # Read in your data
+#' # Note that this data is coming from data supplied by the package
+#' # hence the complicated argument in read.csv()
+#' # This dataset is a CO2 by light response curve for a single sunflower
+#' data = read.csv(system.file("extdata", "A_Ci_Q_data_1.csv",
+#'   package = "photosynthesis"
+#' ))
+#'
+#' # Fit light respiration with Yin method
+#' r_light = fit_r_light_yin(
+#'   data = data,
+#'   varnames = list(
+#'     A_net = "A",
+#'     PPFD = "Qin",
+#'     phi_PSII = "PhiPS2"
+#'   ),
+#'   PPFD_lower = 20,
+#'   PPFD_upper = 250
+#' )
+#' }
+#'
+#' @rdname fit_r_light
+#' @md
+#' @export
+fit_r_light_kok = function(
+    data,
+    varnames = list(
+      A_net = "A_net",
+      PPFD = "PPFD"
+    ),
+    PPFD_lower = 40,
+    PPFD_upper = 100
+) {
+  
+  lifecycle::deprecate_warn(
+    "2.1.1", 
+    "fit_r_light_kok()", 
+    "fit_r_light2(.model = 'kok_1956')", 
+    always = TRUE
+  )
+  
+  # Set variable names
+  data$A_net = data[, varnames$A_net]
+  data$PPFD = data[, varnames$PPFD]
+  # Reduce data to within PPFD range
+  data_use = data[data$PPFD < PPFD_upper, ]
+  data_use = data_use[data_use$PPFD > PPFD_lower, ]
+  # Linear regression to estimate r_light (intercept)
+  model = lm(A_net ~ PPFD, data = data_use)
+  r_light = coef(model)[1]
+  # Output light respiration value
+  return(r_light)
+}
+
+#' @rdname fit_r_light
+#' @export
+fit_r_light_WalkerOrt = function(
+    data,
+    varnames = list(
+      A_net = "A_net",
+      C_i = "C_i",
+      PPFD = "PPFD"
+    ),
+    P = 100,
+    C_i_threshold = 300
+) {
+  
+  lifecycle::deprecate_warn(
+    "2.1.1", 
+    "fit_r_light_WalkerOrt()", 
+    "fit_r_light2(.model = 'walker_ort_2015')", 
+    always = TRUE
+  )
+
+  # Set variable names
+  data$A_net = data[, varnames$A_net]
+  data$C_i = data[, varnames$C_i]
+  data$PPFD = data[, varnames$PPFD]
+
+  # Locally define slope and intercept for slope-intercept regression
+  # This gets rid of a note in the R CMD CHECK
+  Slope = NULL
+  Intercept = NULL
+
+  # Restrict data analysis by a threshold C_i
+  data_use = data[data$C_i < C_i_threshold, ]
+  # Convert C_i to units of Pa
+  data_use$C_i = data_use$C_i / 1000000 * P * 1000
+  # Set PPFD as factor for grouping & round
+  # PPFD to nearest 10s
+  data_use$PPFD = round(data_use$PPFD, digits = -1)
+  data_use$PPFD = as.factor(data_use$PPFD)
+  # Construct regressions on the pseudolinear portions of
+  # the ACi curves
+  model = lmList(A_net ~ C_i | PPFD, data = data_use)
+  # Extract coefficients
+  coefs = coef(model)
+  colnames(coefs) = c("Intercept", "Slope")
+  coefs$PPFD = rownames(coefs)
+  # Create output list
+  output = list(NULL)
+  # Run slope-intercept regression model, assign to element 1
+  output[[1]] = lm(Intercept ~ Slope,
+    data = coefs
+  )
+  # Create graph, assign to element 2
+  output[[2]] = ggplot(coefs, aes(x = Slope, y = Intercept)) +
+    labs(x = "Slope", y = "Intercept") +
+    geom_smooth(method = "lm", linewidth = 2) +
+    geom_point(size = 3) +
+    theme_bw()
+  # Extract coefficients as per Walker and Ort 2015
+  # But convert C_istar to umol mol-1
+  GammaStar = -coef(output[[1]])[2] / (P * 1000) * 1000000
+  r_light = coef(output[[1]])[1]
+  output[[3]] = as.data.frame(cbind(GammaStar, r_light))
+  # Return output
+  return(output)
+}
+
+#' @rdname fit_r_light
+#' @export
+fit_r_light_yin = function(
+    data,
+    varnames = list(
+      A_net = "A_net",
+      PPFD = "PPFD",
+      phi_PSII = "phi_PSII"
+    ),
+    PPFD_lower = 40,
+    PPFD_upper = 100
+) {
+  
+  lifecycle::deprecate_warn(
+    "2.1.1", 
+    "fit_r_light_yin()", 
+    "fit_r_light2(.model = 'yin_etal_2011')", 
+    always = TRUE
+  )
+  
+  # Set variable names
+  data$A_net = data[, varnames$A_net]
+  data$phi_PSII = data[, varnames$phi_PSII]
+  data$PPFD = data[, varnames$PPFD]
+  # Reduce data to within PPFD range
+  data_use = data[data$PPFD < PPFD_upper, ]
+  data_use = data_use[data_use$PPFD > PPFD_lower, ]
+  # Calculate x-variable for Yin method
+  data_use$x_var = data_use$PPFD * data_use$phi_PSII / 4
+  # Fit linear model for Yin method
+  model = lm(A_net ~ x_var, data = data_use)
+  r_light = coef(model)[1]
+  return(r_light)
+}

data/R/fit_t_response.R

@@ -0,0 +1,1016 @@
+#' Fitting temperature responses
+#'
+#' @param data Dataframe with temperature response variables
+#' @param varnames Variable names, where Par is the parameter of interest, and
+#' T_leaf is the leaf temperature in K.
+#' @param model Which temperature response model do you want to use? Defaults
+#' to all: Arrhenius, Heskel, Kruse, Medlyn, MMRT, Quadratic, and Topt.
+#' @param start List of starting parameters for the nls model fits. a, b, and c
+#' are needed for the Heskel model, dEa, Ea_ref, and Par_ref are needed for the
+#' Kruse model, Ea, Par25, and Hd are all needed for the Medlyn and Topt models
+#' while the Medlyn model also requires dS, and dCP, dG, and dH are all for the
+#' MMRT model.
+#' @param setvar Which variable to set as constant for the Medlyn model?
+#' Defaults to "none", while "Hd" and "dS" options are available.
+#' @param hdset Which value should Hd be set to when setvar = "Hd"? Specify
+#' in J/mol.
+#' @param dSset Which value should dS be set to when setvar = "dS"? Specify
+#' in J/mol/K.
+#' @param title Title of output graphs
+#' @param ... Further arguments to pass on to the nlsLM() function
+#'
+#' @return fit_t_response fits one or more temperature response models to a
+#' dataset, returning a list of lists. The parent list contains the models,
+#' while the child list for each model contains the fitted model in element
+#' 1, the coefficients in element 2, and a graph in element 3.
+#' @references
+#' Arrhenius S. 1915. Quantitative laws in biological chemistry. Bell.
+#'
+#' Heskel MA, O'Sullivan OS, Reich PB, Tjoelker MG, Weerasinghe LK,
+#' Penillard A, Egerton JJG, Creek D, Bloomfield KJ, Xiang J, Sinca F,
+#' Stangl ZR, la Torre AM, Griffin KL, Huntingford C, Hurry V, Meir P,
+#' Turnbull MH, Atkin OK. 2016. Convergence in the temperature response
+#' of leaf respiration across biomes and plant functional types. PNAS
+#' 113:3832-3837
+#'
+#' Hobbs JK, Jiao W, Easter AD, Parker EJ, Schipper LA, Arcus VL.
+#' 2013. Change in heat capacity for enzyme catalysis determines
+#' temperature dependence of enzyme catalyzed rates. ACS Chemical
+#' Biology 8:2388-2393.
+#'
+#' Kruse J, Adams MA. 2008. Three parameters comprehensively describe
+#' the temperature response of respiratory oxygen reduction. Plant
+#' Cell Environ 31:954-967
+#'
+#' Liang LL, Arcus VL, Heskel MA, O'Sullivan OS, Weerasinghe LK,
+#' Creek D, Egerton JJG, Tjoelker MG, Atkin OK, Schipper LA. 2018.
+#' Macromolecular rate theory (MMRT) provides a thermodynamics
+#' rationale to underpin the convergent temperature response in
+#' plant leaf respiration. Glob Chang Biol 24:1538-1547
+#'
+#' Medlyn BE, Dreyer E, Ellsworth D, Forstreuter M, Harley PC,
+#' Kirschbaum MUF, Le Roux X, Montpied P, Strassemeyer J, Walcroft A,
+#' Wang K, Loutstau D. 2002. Temperature response of parameters of a
+#' biochemically based model of photosynthesis. II. A review of
+#' experimental data. Plant Cell Environ 25:1167-1179
+#'
+#' @importFrom ggplot2 aes
+#' @importFrom ggplot2 labs
+#' @importFrom ggplot2 ggtitle
+#' @importFrom ggplot2 geom_smooth
+#' @importFrom ggplot2 geom_point
+#' @importFrom ggplot2 theme_bw
+#' @importFrom minpack.lm nlsLM
+#' @importFrom stats nls.control
+#' @export
+#'
+#' @examples
+#' \donttest{
+#' # Read in data
+#' data <- read.csv(system.file("extdata", "A_Ci_T_data.csv",
+#'   package = "photosynthesis"
+#' ),
+#' stringsAsFactors = FALSE
+#' )
+#'
+#' library(tidyr)
+#'
+#' # Round temperatures to group them appropriately
+#' # Use sequential rounding
+#' data$T2 <- round(data$Tleaf, 1)
+#' data$T2 <- round(data$Tleaf, 0)
+#'
+#' # Look at unique values to detect rounding issues
+#' unique(data$T2)
+#'
+#' # Some still did not round correctly,
+#' # manually correct
+#' for (i in 1:nrow(data)) {
+#'   if (data$T2[i] == 18) {
+#'     data$T2[i] <- 17
+#'   }
+#'   if (data$T2[i] == 23) {
+#'     data$T2[i] <- 22
+#'   }
+#'   if (data$T2[i] == 28) {
+#'     data$T2[i] <- 27
+#'   }
+#'   if (data$T2[i] == 33) {
+#'     data$T2[i] <- 32
+#'   }
+#'   if (data$T2[i] == 38) {
+#'     data$T2[i] <- 37
+#'   }
+#' }
+#'
+#' # Make sure it is a character string for grouping
+#' data$T2 <- as.character(data$T2)
+#'
+#' # Create grouping variable by ID and measurement temperature
+#' data <- unite(data,
+#'   col = "ID2", c("ID", "T2"),
+#'   sep = "_"
+#' )
+#'
+#' # Split by temperature group
+#' data <- split(data, data$ID2)
+#'
+#' # Obtain mean temperature for group so temperature
+#' # response fitting is acceptable later, round to
+#' # 2 decimal places
+#' for (i in 1:length(data)) {
+#'   data[[i]]$Curve_Tleaf <- round(mean(data[[i]]$Tleaf), 2)
+#' }
+#'
+#' # Convert from list back to dataframe
+#' data <- do.call("rbind", data)
+#'
+#' # Parse grouping variable by ID and measurement temperature
+#' data <- separate(data,
+#'   col = "ID2", into = c("ID", "T2"),
+#'   sep = "_"
+#' )
+#'
+#' # Make sure number of values matches number of measurement
+#' # temperatures. May vary slightly if plants had slightly
+#' # different leaf temperatures during the measurements
+#' unique(data$Curve_Tleaf)
+#'
+#' # Create ID column to curve fit by ID and temperature
+#' data <- unite(data,
+#'   col = "ID2", c("ID", "Curve_Tleaf"),
+#'   sep = "_"
+#' )
+#'
+#' # Convert leaf temperature to K
+#' data$T_leaf <- data$Tleaf + 273.15
+#'
+#' # Fit many CO2 response curves
+#' fits2 <- fit_many(
+#'   data = data,
+#'   group = "ID2",
+#'   varnames = list(
+#'     A_net = "A",
+#'     C_i = "Ci",
+#'     T_leaf = "T_leaf",
+#'     PPFD = "Qin",
+#'     g_mc = "g_mc"
+#'   ),
+#'   funct = fit_aci_response,
+#'   alphag = 0
+#' )
+#'
+#' # Extract ACi parameters
+#' pars <- compile_data(fits2,
+#'   output_type = "dataframe",
+#'   list_element = 1
+#' )
+#'
+#' # Extract ACi graphs
+#' graphs <- compile_data(fits2,
+#'   output_type = "list",
+#'   list_element = 2
+#' )
+#'
+#' # Parse the ID variable
+#' pars <- separate(pars, col = "ID", into = c("ID", "Curve_Tleaf"), sep = "_")
+#'
+#' # Make sure curve leaf temperature is numeric
+#' pars$Curve_Tleaf <- as.numeric(pars$Curve_Tleaf)
+#' pars$T_leaf <- pars$Curve_Tleaf + 273.15
+#'
+#' # Fit all models, set Hd to constant in Medlyn model
+#' out <- fit_t_response(
+#'   data = pars[pars$ID == "S2", ],
+#'   varnames = list(
+#'     Par = "V_cmax",
+#'     T_leaf = "T_leaf"
+#'   ),
+#'   setvar = "Hd",
+#'   hdset = 200000
+#' )
+#'
+#' out[["Arrhenius"]][["Graph"]]
+#' out[["Heskel"]][["Graph"]]
+#' out[["Kruse"]][["Graph"]]
+#' out[["Medlyn"]][["Graph"]]
+#' out[["MMRT"]][["Graph"]]
+#' out[["Quadratic"]][["Graph"]]
+#' out[["Topt"]][["Graph"]]
+#' }
+fit_t_response <- function(data,
+                           varnames = list(
+                             Par = "Par",
+                             T_leaf = "T_leaf"
+                           ),
+                           model = c(
+                             "Arrhenius",
+                             "Kruse",
+                             "Heskel",
+                             "Medlyn",
+                             "MMRT",
+                             "Quadratic",
+                             "Topt"
+                           ),
+                           start = list(
+                             a = 1,
+                             b = 1,
+                             c = 1,
+
+                             dEa = 1,
+                             Ea_ref = 1,
+                             Par_ref = 1,
+
+                             Ea = 40000,
+                             Par25 = 50,
+                             Hd = 200000,
+                             dS = 650,
+
+                             dCp = 1,
+                             dG = 1,
+                             dH = 1
+                           ),
+                           setvar = "none",
+                           hdset = 200000,
+                           dSset = 650,
+                           title = NULL,
+                           ...) {
+  # Check: are the models available?
+  if (TRUE %in% c(!model %in% c(
+    "Arrhenius",
+    "Kruse",
+    "Heskel",
+    "Medlyn",
+    "MMRT",
+    "Quadratic",
+    "Topt"
+  ))) {
+    stop("Specified model is not available. Current supported models are
+          Arrhenius, Kruse, Heskel, Medlyn, MMRT, Quadratic, and Topt.")
+  }
+  # Locally bind variables - avoids notes on check package
+  Par <- NULL
+  T_leaf <- NULL
+  # Set variable names
+  data$Par <- data[, varnames$Par]
+  data$T_leaf <- data[, varnames$T_leaf]
+  # Create empty list for number of output elements
+  models <- vector("list", length(model))
+  names(models) <- model
+  # Arrhenius model
+  if ("Arrhenius" %in% model) {
+    models[["Arrhenius"]] <- vector("list", 3)
+    try(models[["Arrhenius"]][[1]] <- nlsLM(
+      data = data,
+      Par ~ Par25 *
+        t_response_arrhenius(Ea,
+          T_leaf = T_leaf
+        ),
+      start = start[c("Ea", "Par25")],
+      lower = c(0, 0),
+      upper = c(1e10, 10 * max(data$Par)),
+      control = nls.control(maxiter = 100),
+      ...
+    ))
+    # Add parameter outputs to output list
+    # Assign coefficients to element 2
+    if (is.null(models[["Arrhenius"]][[1]]) == TRUE) {
+      models[["Arrhenius"]][[2]] <- data.frame(cbind("NA", "NA"))
+      colnames(models[["Arrhenius"]][[2]]) <- c("Ea", "Par25")
+    } else {
+      models[["Arrhenius"]][[2]] <- data.frame(rbind(coef(models[["Arrhenius"]][[1]])))
+    }
+    # Add graph to output list
+    models[["Arrhenius"]][[3]] <- ggplot(data, aes(x = T_leaf, y = Par)) +
+      # Add axis labels
+      labs(
+        x = expression("T_leaf (K)"),
+        y = varnames$Par
+      ) +
+      # Add title
+      ggtitle(label = title) +
+      # Add fitted smoothing function
+      geom_smooth(
+        method = "lm",
+        formula = y ~ I(models[["Arrhenius"]][[2]]$Par25[1] *
+          (t_response_arrhenius(
+            T_leaf = x,
+            Ea = models[["Arrhenius"]][[2]]$Ea[1]
+          ))),
+        size = 2
+      ) +
+      # Add points
+      geom_point(size = 2) +
+      # Use clean theme
+      theme_bw()
+    # Name outputs
+    names(models[["Arrhenius"]]) <- c("Model", "Parameters", "Graph")
+  }
+  # Heskel model
+  if ("Heskel" %in% model) {
+    models[["Heskel"]] <- vector("list", 3)
+    try(models[["Heskel"]][[1]] <- nlsLM(
+      data = data,
+      log(Par) ~
+      t_response_heskel(a,
+        b,
+        c,
+        T_leaf = T_leaf
+      ),
+      start = start[c("a", "b", "c")],
+      control =
+        nls.control(maxiter = 100),
+      ...
+    ))
+    # Add parameter outputs to output list
+    # Assign coefficients to element 2
+    if (is.null(models[["Heskel"]][[1]]) == TRUE) {
+      models[["Heskel"]][[2]] <- data.frame(cbind("NA", "NA", "NA"))
+      colnames(models[["Heskel"]][[2]]) <- c("a", "b", "c")
+    } else {
+      models[["Heskel"]][[2]] <- data.frame(rbind(coef(models[["Heskel"]][[1]])))
+    }
+    # Add graph to output list
+    models[["Heskel"]][[3]] <- ggplot(data, aes(x = T_leaf, y = Par)) +
+      # Add axis labels
+      labs(
+        x = expression("T_leaf (K)"),
+        y = varnames$Par
+      ) +
+      # Add title
+      ggtitle(label = title) +
+      # Add fitted smoothing function
+      geom_smooth(
+        method = "lm",
+        formula = y ~ exp(t_response_heskel(
+          T_leaf = x,
+          a = models[["Heskel"]][[2]]$a[1],
+          b = models[["Heskel"]][[2]]$b[1],
+          c = models[["Heskel"]][[2]]$c[1]
+        )),
+        size = 2
+      ) +
+      # Add points
+      geom_point(size = 2) +
+      # Use clean theme
+      theme_bw()
+    # Name outputs
+    names(models[["Heskel"]]) <- c("Model", "Parameters", "Graph")
+  }
+  # Kruse model
+  if ("Kruse" %in% model) {
+    models[["Kruse"]] <- vector("list", 3)
+    data$T2 <- ((data$T_leaf) - 298.15) /
+      ((data$T_leaf) * 298.15)
+    try(models[["Kruse"]][[1]] <- nlsLM(
+      data = data,
+      log(Par) ~
+      t_response_arrhenius_kruse(dEa,
+        Ea_ref,
+        Par_ref,
+        T2 = T2
+      ),
+      start = start[c(
+        "dEa",
+        "Ea_ref",
+        "Par_ref"
+      )],
+      control = nls.control(maxiter = 100),
+      ...
+    ))
+    # Add parameter outputs to output list
+    # Assign coefficients to element 2
+    if (is.null(models[["Kruse"]][[1]]) == TRUE) {
+      models[["Kruse"]][[2]] <- data.frame(cbind("NA", "NA", "NA"))
+      colnames(models[["Kruse"]][[2]]) <- c("dEa", "Ea_ref", "Par_ref")
+    } else {
+      models[["Kruse"]][[2]] <- data.frame(rbind(coef(models[["Kruse"]][[1]])))
+    }
+    # Add graph to output list
+    models[["Kruse"]][[3]] <- ggplot(data, aes(x = T_leaf, y = Par)) +
+      # Add axis labels
+      labs(
+        x = expression("T_leaf (K)"),
+        y = varnames$Par
+      ) +
+      # Add title
+      ggtitle(label = title) +
+      # Add fitted smoothing function
+      geom_smooth(
+        method = "lm",
+        formula = y ~
+        exp(t_response_arrhenius_kruse(
+          T2 = ((x) - 298.15) /
+            ((x) * 298.15),
+          dEa = models[["Kruse"]][[2]]$dEa[1],
+          Ea_ref = models[["Kruse"]][[2]]$Ea_ref[1],
+          Par_ref = models[["Kruse"]][[2]]$Par_ref[1]
+        )),
+        size = 2
+      ) +
+      # Add points
+      geom_point(size = 2) +
+      # Use clean theme
+      theme_bw()
+    # Name outputs
+    names(models[["Kruse"]]) <- c("Model", "Parameters", "Graph")
+  }
+  # Medlyn model
+  if ("Medlyn" %in% model) {
+    models[["Medlyn"]] <- vector("list", 3)
+    # Fit both Hd and dS
+    if (setvar == "none") {
+      # Basically, use Arrhenius curve to feed Ea into Medlyn function start
+      # Try approach where you start Hd from 1 to 1000
+      # select minimum residual
+      modeltest <- nlsLM(
+        data = data,
+        Par ~ Par25 * t_response_arrhenius(Ea,
+          T_leaf = T_leaf
+        ),
+        start = start[c("Ea", "Par25")],
+        lower = c(0, 0),
+        upper = c(1e10, 10 * max(data$Par)),
+        control = nls.control(maxiter = 100)
+      )
+      # Create empty dataframe to fill with 1000 curve fits
+      model_fm <- as.data.frame(cbind(
+        rep(0, 1000),
+        rep(0, 1000),
+        rep(0, 1000),
+        rep(0, 1000),
+        rep(0, 1000),
+        rep(varnames$Par[[1]], 1000)
+      ))
+      # Assign column names
+      colnames(model_fm) <- c("Ea", "Hd", "Par25", "dS", "residual", "Parameter")
+      # Make sure variabel classes are appropriate
+      model_fm$Ea <- as.double(model_fm$Ea)
+      model_fm$Hd <- as.double(model_fm$Hd)
+      model_fm$dS <- as.double(model_fm$dS)
+      model_fm$Par25 <- as.double(model_fm$Par25)
+      model_fm$residual <- as.double(model_fm$residual)
+      model_full <- vector("list", 1000)
+      # Run through 1000 instances of the model
+      # TryCatch is used to deal with failed fits
+      for (i in 1:1000) {
+        # Fit model
+        model_full[[i]] <- tryCatch(nlsLM(
+          data = data,
+          Par ~ Par25 *
+            t_response_arrhenius_medlyn(Ea,
+              Hd,
+              dS,
+              T_leaf =
+                T_leaf
+            ),
+          start = list(
+            Ea = coef(modeltest)[["Ea"]],
+            Hd = i * 1000,
+            dS = dSset,
+            Par25 = coef(modeltest)[["Par25"]]
+          ),
+          lower = c(0, 0, 0, 0),
+          upper = c(
+            1000000, 2000000, 20000,
+            1.5 * max(data$Par)
+          ),
+          control = nls.control(maxiter = 100)
+        ),
+        error = function(e) paste(NA)
+        )
+        # Extract coefficients
+        model_fm$Ea[i] <- tryCatch(coef(model_full[[i]])[["Ea"]],
+          error = function(e) paste(NA)
+        )
+        model_fm$Hd[i] <- tryCatch(coef(model_full[[i]])[["Hd"]],
+          error = function(e) paste(NA)
+        )
+        model_fm$dS[i] <- tryCatch(coef(model_full[[i]])[["dS"]],
+          error = function(e) paste(NA)
+        )
+        model_fm$Par25[i] <- tryCatch(coef(model_full[[i]])[["Par25"]],
+          error = function(e) paste(NA)
+        )
+        model_fm$residual[i] <- tryCatch(sum((model_full[[i]]$m$resid())^2),
+          error = function(e) paste(NA)
+        )
+      }
+      # Ensure variable classes are appropriate
+      model_fm$Ea <- as.double(model_fm$Ea)
+      model_fm$Hd <- as.double(model_fm$Hd)
+      model_fm$dS <- as.double(model_fm$dS)
+      model_fm$Par25 <- as.double(model_fm$Par25)
+      model_fm$residual <- as.double(model_fm$residual)
+      # Select best model with minimum residuals
+      model_fm <- model_fm[is.na(model_fm$residual) == FALSE, ]
+      model_fm <- model_fm[model_fm$Ea != 1000000, ]
+      model_fm <- model_fm[model_fm$Hd != 2000000, ]
+      model_fm <- model_fm[model_fm$dS != 20000, ]
+      model_fm <- model_fm[model_fm$residual == min(model_fm$residual), ]
+      model_full <- model_full[[as.numeric(rownames(model_fm))]]
+      # Add model to output list
+      models[["Medlyn"]][[1]] <- model_full
+      # Add parameter outputs to output list
+      models[["Medlyn"]][[2]] <- data.frame(rbind(coef(model_full)))
+      models[["Medlyn"]][[2]]$T_leaf <- mean(data$T_leaf)
+      # Add graph to output list
+      models[["Medlyn"]][[3]] <- ggplot(data, aes(x = T_leaf, y = Par)) +
+        # Add axis labels
+        labs(
+          x = expression("T_leaf (K)"),
+          y = varnames$Par
+        ) +
+        # Add title
+        ggtitle(label = title) +
+        # Add fitted smoothing function
+        geom_smooth(
+          method = "lm",
+          formula = y ~ I(models[["Medlyn"]][[2]]$Par25[1] *
+            t_response_arrhenius_medlyn(
+              T_leaf = x,
+              Ea = models[["Medlyn"]][[2]]$Ea[1],
+              Hd = models[["Medlyn"]][[2]]$Hd[1],
+              dS = models[["Medlyn"]][[2]]$dS[1]
+            )),
+          size = 2
+        ) +
+        # Add points
+        geom_point(size = 2) +
+        # Use clean theme
+        theme_bw()
+      # Name outputs
+      names(models[["Medlyn"]]) <- c("Model", "Parameters", "Graph")
+    }
+    # Just fit dS
+    if (setvar == "Hd") {
+      # Basically, use Arrhenius curve to feed Ea into Medlyn function start
+      # Try approach where you start Hd from 1 to 1000
+      # select minimum residual
+      modeltest <- nlsLM(
+        data = data,
+        Par ~ Par25 * t_response_arrhenius(Ea,
+          T_leaf = T_leaf
+        ),
+        start = start[c("Ea", "Par25")],
+        lower = c(0, 0),
+        upper = c(1e10, 10 * max(data$Par)),
+        control = nls.control(maxiter = 100)
+      )
+      # Create empty dataframe to fill with 1000 curve fits
+      model_fm <- as.data.frame(cbind(
+        rep(0, 1000),
+        rep(0, 1000),
+        rep(0, 1000),
+        rep(0, 1000),
+        rep(0, 1000),
+        rep(varnames$Par[[1]], 1000)
+      ))
+      # Assign column names
+      colnames(model_fm) <- c("Ea", "Hd", "Par25", "dS", "residual", "Parameter")
+      # Make sure variabel classes are appropriate
+      model_fm$Ea <- as.double(model_fm$Ea)
+      model_fm$Hd <- as.double(model_fm$Hd)
+      model_fm$dS <- as.double(model_fm$dS)
+      model_fm$Par25 <- as.double(model_fm$Par25)
+      model_fm$residual <- as.double(model_fm$residual)
+      model_full <- vector("list", 1000)
+      # Run through 1000 instances of the model
+      # TryCatch is used to deal with failed fits
+      for (i in 1:1000) {
+        # Fit model
+        model_full[[i]] <- tryCatch(nlsLM(
+          data = data,
+          Par ~ Par25 *
+            t_response_arrhenius_medlyn(Ea,
+              Hd = hdset,
+              dS,
+              T_leaf =
+                T_leaf
+            ),
+          start = list(
+            Ea = coef(modeltest)[["Ea"]],
+            dS = i,
+            Par25 = coef(modeltest)[["Par25"]]
+          ),
+          lower = c(0, 0, 0),
+          upper = c(
+            1000000, 20000,
+            1.5 * max(data$Par)
+          ),
+          control = nls.control(maxiter = 100)
+        ),
+        error = function(e) paste(NA)
+        )
+        # Extract coefficients
+        model_fm$Ea[i] <- tryCatch(coef(model_full[[i]])[["Ea"]],
+          error = function(e) paste(NA)
+        )
+        model_fm$Hd[i] <- hdset
+        model_fm$Par25[i] <- tryCatch(coef(model_full[[i]])[["Par25"]],
+          error = function(e) paste(NA)
+        )
+        model_fm$dS[i] <- tryCatch(coef(model_full[[i]])[["dS"]],
+          error = function(e) paste(NA)
+        )
+        model_fm$residual[i] <- tryCatch(sum((model_full[[i]]$m$resid())^2),
+          error = function(e) paste(NA)
+        )
+      }
+      # Ensure variable classes are appropriate
+      model_fm$Ea <- as.double(model_fm$Ea)
+      model_fm$Hd <- as.double(model_fm$Hd)
+      model_fm$dS <- as.double(model_fm$dS)
+      model_fm$Par25 <- as.double(model_fm$Par25)
+      model_fm$residual <- as.double(model_fm$residual)
+      # Select best model with minimum residuals
+      model_fm <- model_fm[is.na(model_fm$residual) == FALSE, ]
+      model_fm <- model_fm[model_fm$Ea != 1000000, ]
+      model_fm <- model_fm[model_fm$dS != 20000, ]
+      model_fm <- model_fm[model_fm$residual == min(model_fm$residual), ]
+      model_full <- model_full[[as.numeric(rownames(model_fm))]]
+      # Add model to output list
+      models[["Medlyn"]][[1]] <- model_full
+      # Add parameter outputs to output list
+      models[["Medlyn"]][[2]] <- data.frame(rbind(coef(model_full)))
+      models[["Medlyn"]][[2]]$Hd <- hdset
+      models[["Medlyn"]][[2]]$T_leaf <- mean(data$T_leaf)
+      # Add graph to output list
+      models[["Medlyn"]][[3]] <- ggplot(data, aes(x = T_leaf, y = Par)) +
+        # Add axis labels
+        labs(
+          x = expression("T_leaf (K)"),
+          y = varnames$Par
+        ) +
+        # Add title
+        ggtitle(label = title) +
+        # Add fitted smoothing function
+        geom_smooth(
+          method = "lm",
+          formula = y ~ I(models[["Medlyn"]][[2]]$Par25[1] *
+            t_response_arrhenius_medlyn(
+              T_leaf = x,
+              Ea = models[["Medlyn"]][[2]]$Ea[1],
+              Hd = models[["Medlyn"]][[2]]$Hd[1],
+              dS = models[["Medlyn"]][[2]]$dS[1]
+            )),
+          size = 2
+        ) +
+        # Add points
+        geom_point(size = 2) +
+        # Use clean theme
+        theme_bw()
+      # Name outputs
+      names(models[["Medlyn"]]) <- c("Model", "Parameters", "Graph")
+    }
+    # Just fit Hd
+    if (setvar == "dS") {
+      # Basically, use Arrhenius curve to feed Ea into Medlyn function start
+      # Try approach where you start Hd from 1 to 1000
+      # select minimum residual
+      modeltest <- nlsLM(
+        data = data,
+        Par ~ Par25 * t_response_arrhenius(Ea,
+          T_leaf = T_leaf
+        ),
+        start = start[c("Ea", "Par25")],
+        lower = c(0, 0),
+        upper = c(1e10, 10 * max(data$Par)),
+        control = nls.control(maxiter = 100)
+      )
+      # Create empty dataframe to fill with 1000 curve fits
+      model_fm <- as.data.frame(cbind(
+        rep(0, 1000),
+        rep(0, 1000),
+        rep(0, 1000),
+        rep(0, 1000),
+        rep(0, 1000),
+        rep(varnames$Par[[1]], 1000)
+      ))
+      # Assign column names
+      colnames(model_fm) <- c("Ea", "Hd", "Par25", "dS", "residual", "Parameter")
+      # Make sure variabel classes are appropriate
+      model_fm$Ea <- as.double(model_fm$Ea)
+      model_fm$Hd <- as.double(model_fm$Hd)
+      model_fm$dS <- as.double(model_fm$dS)
+      model_fm$Par25 <- as.double(model_fm$Par25)
+      model_fm$residual <- as.double(model_fm$residual)
+      model_full <- vector("list", 1000)
+      # Run through 1000 instances of the model
+      # TryCatch is used to deal with failed fits
+      for (i in 1:1000) {
+        # Fit model
+        model_full[[i]] <- tryCatch(nlsLM(
+          data = data,
+          Par ~ Par25 *
+            t_response_arrhenius_medlyn(Ea,
+              Hd,
+              dS = dSset,
+              T_leaf =
+                T_leaf
+            ),
+          start = list(
+            Ea = coef(modeltest)[["Ea"]],
+            Hd = i * 1000,
+            Par25 = coef(modeltest)[["Par25"]]
+          ),
+          lower = c(0, 0, 0),
+          upper = c(
+            1000000, 2000000,
+            1.5 * max(data$Par)
+          ),
+          control = nls.control(maxiter = 100)
+        ),
+        error = function(e) paste(NA)
+        )
+        # Extract coefficients
+        model_fm$Ea[i] <- tryCatch(coef(model_full[[i]])[["Ea"]],
+          error = function(e) paste(NA)
+        )
+        model_fm$Hd[i] <- tryCatch(coef(model_full[[i]])[["Hd"]],
+          error = function(e) paste(NA)
+        )
+        model_fm$Par25[i] <- tryCatch(coef(model_full[[i]])[["Par25"]],
+          error = function(e) paste(NA)
+        )
+        model_fm$dS[i] <- dSset
+        model_fm$residual[i] <- tryCatch(sum((model_full[[i]]$m$resid())^2),
+          error = function(e) paste(NA)
+        )
+      }
+      # Ensure variable classes are appropriate
+      model_fm$Ea <- as.double(model_fm$Ea)
+      model_fm$Hd <- as.double(model_fm$Hd)
+      model_fm$dS <- as.double(model_fm$dS)
+      model_fm$Par25 <- as.double(model_fm$Par25)
+      model_fm$residual <- as.double(model_fm$residual)
+      # Select best model with minimum residuals
+      model_fm <- model_fm[is.na(model_fm$residual) == FALSE, ]
+      model_fm <- model_fm[model_fm$Ea != 1000000, ]
+      model_fm <- model_fm[model_fm$Hd != 2000000, ]
+      model_fm <- model_fm[model_fm$residual == min(model_fm$residual), ]
+      model_full <- model_full[[as.numeric(rownames(model_fm))]]
+      # Add model to output list
+      models[["Medlyn"]][[1]] <- model_full
+      # Add parameter outputs to output list
+      models[["Medlyn"]][[2]] <- data.frame(rbind(coef(model_full)))
+      models[["Medlyn"]][[2]]$dS <- dSset
+      models[["Medlyn"]][[2]]$T_leaf <- mean(data$T_leaf)
+      # Add graph to output list
+      models[["Medlyn"]][[3]] <- ggplot(data, aes(x = T_leaf, y = Par)) +
+        # Add axis labels
+        labs(
+          x = expression("T_leaf (K)"),
+          y = varnames$Par
+        ) +
+        # Add title
+        ggtitle(label = title) +
+        # Add fitted smoothing function
+        geom_smooth(
+          method = "lm",
+          formula = y ~ I(models[["Medlyn"]][[2]]$Par25[1] *
+            t_response_arrhenius_medlyn(
+              T_leaf = x,
+              Ea = models[["Medlyn"]][[2]]$Ea[1],
+              Hd = models[["Medlyn"]][[2]]$Hd[1],
+              dS = models[["Medlyn"]][[2]]$dS[1]
+            )),
+          size = 2
+        ) +
+        # Add points
+        geom_point(size = 2) +
+        # Use clean theme
+        theme_bw()
+      # Name outputs
+      names(models[["Medlyn"]]) <- c("Model", "Parameters", "Graph")
+    }
+  }
+  # MMRT model
+  if ("MMRT" %in% model) {
+    models[["MMRT"]] <- vector("list", 3)
+    try(models[["MMRT"]][[1]] <- nlsLM(
+      data = data,
+      log(Par) ~ t_response_mmrt(dCp,
+        dG,
+        dH,
+        T_leaf = T_leaf
+      ),
+      start = start[c(
+        "dCp",
+        "dG",
+        "dH"
+      )],
+      control = nls.control(maxiter = 100),
+      ...
+    ))
+    # Add parameter outputs to output list
+    # Assign coefficients to element 2
+    if (is.null(models[["MMRT"]][[1]]) == TRUE) {
+      models[["MMRT"]][[2]] <- data.frame(cbind("NA", "NA", "NA"))
+      colnames(models[["MMRT"]][[2]]) <- c("dCp", "dG", "dH")
+    } else {
+      models[["MMRT"]][[2]] <- data.frame(rbind(coef(models[["MMRT"]][[1]])))
+    }
+    # Add graph to output list
+    models[["MMRT"]][[3]] <- ggplot(data, aes(x = T_leaf, y = Par)) +
+      # Add axis labels
+      labs(
+        x = expression("T_leaf (K)"),
+        y = varnames$Par
+      ) +
+      # Add title
+      ggtitle(label = title) +
+      # Add fitted smoothing function
+      geom_smooth(
+        method = "lm",
+        formula = y ~ exp(
+          t_response_mmrt(
+            T_leaf = x,
+            dCp = models[["MMRT"]][[2]]$dCp[1],
+            dG = models[["MMRT"]][[2]]$dG[1],
+            dH = models[["MMRT"]][[2]]$dH[1]
+          )
+        ),
+        size = 2
+      ) +
+      # Add points
+      geom_point(size = 2) +
+      # Use clean theme
+      theme_bw()
+    # Name outputs
+    names(models[["MMRT"]]) <- c("Model", "Parameters", "Graph")
+  }
+  # Quadratic model
+  if ("Quadratic" %in% model) {
+    models[["Quadratic"]] <- vector("list", 3)
+    try(models[["Quadratic"]][[1]] <- nlsLM(
+      data = data,
+      Par ~ t_response_heskel(a,
+        b,
+        c,
+        T_leaf = T_leaf
+      ),
+      start = start[c("a", "b", "c")],
+      control = nls.control(maxiter = 100),
+      ...
+    ))
+    # Add parameter outputs to output list
+    # Assign coefficients to element 2
+    if (is.null(models[["Quadratic"]][[1]]) == TRUE) {
+      models[["Quadratic"]][[2]] <- data.frame(cbind("NA", "NA", "NA"))
+      colnames(models[["Quadratic"]][[2]]) <- c("a", "b", "c")
+    } else {
+      models[["Quadratic"]][[2]] <- data.frame(rbind(coef(models[["Quadratic"]][[1]])))
+    }
+    # Add graph to output list
+    models[["Quadratic"]][[3]] <- ggplot(data, aes(x = T_leaf, y = Par)) +
+      # Add axis labels
+      labs(
+        x = expression("T_leaf (K)"),
+        y = varnames$Par
+      ) +
+      # Add title
+      ggtitle(label = title) +
+      # Add fitted smoothing function
+      geom_smooth(
+        method = "lm",
+        formula = y ~ (t_response_heskel(
+          T_leaf = x,
+          a = models[["Quadratic"]][[2]]$a[1],
+          b = models[["Quadratic"]][[2]]$b[1],
+          c = models[["Quadratic"]][[2]]$c[1]
+        )),
+        size = 2
+      ) +
+      # Add points
+      geom_point(size = 2) +
+      # Use clean theme
+      theme_bw()
+    # Name outputs
+    names(models[["Quadratic"]]) <- c("Model", "Parameters", "Graph")
+  }
+  # Topt model
+  if ("Topt" %in% model) {
+    models[["Topt"]] <- vector("list", 3)
+    modeltest <- nlsLM(
+      data = data,
+      Par ~ Par25 * t_response_arrhenius(Ea,
+        T_leaf = T_leaf
+      ),
+      start = start[c("Ea", "Par25")],
+      lower = c(0, 0),
+      upper = c(1e10, 10 * max(data$Par)),
+      control = nls.control(maxiter = 100)
+    )
+    # Create empty dataframe to fill with 1000 curve fits
+    model_fm <- as.data.frame(cbind(
+      rep(0, 1000),
+      rep(0, 1000),
+      rep(0, 1000),
+      rep(0, 1000),
+      rep(0, 1000),
+      rep(varnames$Par[[1]], 1000)
+    ))
+    # Assign column names
+    colnames(model_fm) <- c(
+      "Ea", "Hd", "kopt", "Topt", "residual",
+      "Parameter"
+    )
+    # Make sure variable classes are appropriate
+    model_fm$Ea <- as.double(model_fm$Ea)
+    model_fm$Hd <- as.double(model_fm$Hd)
+    model_fm$kopt <- as.double(model_fm$kopt)
+    model_fm$Topt <- as.double(model_fm$Topt)
+    model_fm$residual <- as.double(model_fm$residual)
+    model_full <- vector("list", 1000)
+    # Run through 1000 instances of the model
+    # TryCatch is used to deal with failed fits
+    for (i in 1:1000) {
+      # Fit model
+      model_full[[i]] <- tryCatch(nlsLM(
+        data = data,
+        Par ~ kopt *
+          t_response_arrhenius_topt(Ea,
+            Hd,
+            Topt,
+            T_leaf =
+              T_leaf
+          ),
+        start = list(
+          Ea = coef(modeltest)[["Ea"]],
+          Hd = i * 1000,
+          kopt = max(data$Par),
+          Topt = max(data$T_leaf)
+        ),
+        lower = c(0, 0, 0, 0),
+        upper = c(
+          1000000, 2000000, max(data$Par) + 1,
+          max(data$T_leaf) + 1
+        ),
+        control = nls.control(maxiter = 100)
+      ),
+      error = function(e) paste(NA)
+      )
+      # Extract coefficients
+      model_fm$Ea[i] <- tryCatch(coef(model_full[[i]])[["Ea"]],
+        error = function(e) paste(NA)
+      )
+      model_fm$Hd[i] <- tryCatch(coef(model_full[[i]])[["Hd"]],
+        error = function(e) paste(NA)
+      )
+      model_fm$kopt[i] <- tryCatch(coef(model_full[[i]])[["kopt"]],
+        error = function(e) paste(NA)
+      )
+      model_fm$Topt[i] <- tryCatch(coef(model_full[[i]])[["Topt"]],
+        error = function(e) paste(NA)
+      )
+      model_fm$residual[i] <- tryCatch(sum((model_full[[i]]$m$resid())^2),
+        error = function(e) paste(NA)
+      )
+    }
+    # Ensure variable classes are appropriate
+    model_fm$Ea <- as.double(model_fm$Ea)
+    model_fm$Hd <- as.double(model_fm$Hd)
+    model_fm$kopt <- as.double(model_fm$kopt)
+    model_fm$Topt <- as.double(model_fm$Topt)
+    model_fm$residual <- as.double(model_fm$residual)
+    # Select best model with minimum residuals
+    model_fm <- model_fm[is.na(model_fm$residual) == FALSE, ]
+    model_fm <- model_fm[model_fm$Ea != 1000000, ]
+    model_fm <- model_fm[model_fm$Hd != 2000000, ]
+    model_fm <- model_fm[model_fm$residual == min(model_fm$residual), ]
+    model_full <- model_full[[as.numeric(rownames(model_fm))]]
+    # Add model to output list
+    models[["Topt"]][[1]] <- model_full
+    # Add parameter outputs to output list
+    models[["Topt"]][[2]] <- data.frame(rbind(coef(model_full)))
+    # Add graph to output list
+    models[["Topt"]][[3]] <- ggplot(data, aes(x = T_leaf, y = Par)) +
+      # Add axis labels
+      labs(
+        x = expression("T_leaf (K)"),
+        y = varnames$Par
+      ) +
+      # Add title
+      ggtitle(label = title) +
+      # Add fitted smoothing function
+      geom_smooth(
+        method = "lm",
+        formula = y ~ I(models[["Topt"]][[2]]$kopt[1] *
+          (t_response_arrhenius_topt(
+            T_leaf = x,
+            Ea = models[["Topt"]][[2]]$Ea[1],
+            Hd = models[["Topt"]][[2]]$Hd[1],
+            Topt = models[["Topt"]][[2]]$Topt[1]
+          ))),
+        size = 2
+      ) +
+      # Add points
+      geom_point(size = 2) +
+      # Use clean theme
+      theme_bw()
+    # Name outputs
+    names(models[["Topt"]]) <- c("Model", "Parameters", "Graph")
+  }
+  return(models)
+}

data/R/gs_models.R

@@ -0,0 +1,77 @@
+#' Stomatal conductance models
+#'
+#' @param A_net Net CO2 assimilation in umol m-2 s-1
+#' @param C_air CO2 concentration at the leaf surface in umol mol-1
+#' @param RH Relative humidity as a proportion
+#'
+#' @param D0 Vapor pressure sensitivity of stomata (Leuning 1995)
+#' @param VPD Vapor pressure deficit (kPa)
+#'
+#' @param g0 Optimization model intercept term (Medlyn et al. 2011)
+#' @param g1 Optimization model slope term (Medlyn et al. 2011)
+#' @param gk Optimization model root term (Medlyn et al. 2011)
+#'
+#'
+#' @return gs_mod_ballberry is used for fitting the Ball et al. (1987) model
+#' of stomatal conductance
+#'
+#' gs_mod_leuning is used for fitting the Leuning (1995) model
+#' of stomatal conductance
+#'
+#' gs_mod_opti fits the optimal stomatal conductance model according to
+#' Medlyn et al. 2011
+#'
+#' gs_mod_optifull fits the full optimal stomatal conductance model according
+#' to Medlyn et al. 2011
+#'
+#' @references
+#'
+#' Ball JT, Woodrow IE, Berry JA. 1987. A model predicting stomatal
+#' conductance and its contribution to the control of photosynthesis
+#' under different environmental conditions, in Progress in
+#' Photosynthesis Research, Proceedings of the VII International
+#' Congress on Photosynthesis, vol. 4, edited by I. Biggins, pp.
+#' 221–224, Martinus Nijhoff, Dordrecht, Netherlands.
+#'
+#' Leuning R. 1995. A critical appraisal of a coupled stomatal-
+#' photosynthesis model for C3 plants. Plant Cell Environ 18:339-357
+#'
+#' Medlyn BE, Duursma RA, Eamus D, Ellsworth DS, Prentice IC, Barton
+#' CVM, Crous KY, Angelis PD, Freeman M, Wingate L. 2011. Reconciling
+#' the optimal and empirical approaches to modeling stomatal
+#' conductance. Glob Chang Biol 17:2134-2144
+#'
+#' @rdname gs_models
+#' @export
+gs_mod_ballberry <- function(A_net,
+                             C_air,
+                             RH) {
+  A_net * C_air * RH
+}
+#' @rdname gs_models
+#' @export
+gs_mod_leuning <- function(A_net,
+                           C_air,
+                           D0,
+                           VPD) {
+  A_net / (C_air * (1 + VPD * D0))
+}
+#' @rdname gs_models
+#' @export
+gs_mod_opti <- function(g0,
+                        g1,
+                        VPD,
+                        A_net,
+                        C_air) {
+  g0 + 1.6 * (1 + g1 / sqrt(VPD)) * (A_net / C_air)
+}
+#' @rdname gs_models
+#' @export
+gs_mod_optifull <- function(g0,
+                            g1,
+                            gk,
+                            VPD,
+                            A_net,
+                            C_air) {
+  g0 + 1.6 * (1 + g1 / VPD^(1 - gk)) * (A_net / C_air)
+}

data/R/j_calculations.R

@@ -0,0 +1,35 @@
+#' Inverse non-rectangular hyperbola for J_max calculation
+#'
+#' @param PPFD light intensity in umol m-2 s-1
+#' @param alpha initial slope of the light response
+#' @param J electron transport rate in umol m-2 s-1
+#' @param J_max maximum rate of electron transport in umol m-2 s-1
+#' @param theta_J curvature of the light response
+#'
+#' @return calculate_jmax calculates J_max given PPFD and J.
+#' It is necessary for the electron transport component of the
+#' fit_aci_response function.
+#'
+#' calculate_j provides a model of the light response of J.
+#' It is necessary for fitting the electron transport component
+#' of the photosynthetic CO2 response curves in fit_aci_response.
+#'
+#' @rdname j_calculations
+#' @export
+calculate_jmax <- function(PPFD,
+                           alpha,
+                           J,
+                           theta_J) {
+  J * (J * theta_J - alpha * PPFD) / (J - alpha * PPFD)
+}
+
+#' @rdname j_calculations
+#' @export
+calculate_j <- function(PPFD,
+                        alpha,
+                        J_max,
+                        theta_J) {
+  (alpha * PPFD + J_max -
+    sqrt((alpha * PPFD + J_max)^2 - 4 * alpha * theta_J * PPFD * J_max)) /
+    (2 * theta_J)
+}

data/R/leaf-par.R

@@ -0,0 +1,73 @@
+#' S3 class leaf_par
+#
+
+#' @inheritParams photosynthesis
+#' @param .x A list to be constructed into **leaf_par**.
+#'
+#' @returns 
+#'
+#' Constructor function for leaf_par class. This function ensures that leaf
+#' parameter inputs are properly formatted.
+#'
+#' @export
+leaf_par = function(.x, use_tealeaves) {
+  
+  which = "leaf"
+  
+  # Message about change of conductance units in version 2.1.0
+  check_for_legacy_gunit(.x)
+  
+  # Check parameters names ----
+  nms = check_parameter_names(.x, which = which, use_tealeaves = use_tealeaves)
+  .x = .x |> 
+    magrittr::extract(nms) |>
+    # Set units ----
+  set_parameter_units(
+    .data$type == "leaf", 
+    !.data$temperature_response,
+    if (!use_tealeaves) {!.data$tealeaves} else TRUE
+  )
+  
+  # Assert bounds on values ----
+  .x |>
+    assert_parameter_bounds(
+      .data$type == which, 
+      !.data$temperature_response,
+      if (!use_tealeaves) {!.data$tealeaves} else TRUE
+    )
+  
+  structure(.x, class = c(stringr::str_c(which, "_par"), "list"))
+  
+}
+
+check_for_legacy_gunit = function(pars) {
+  
+  xx = pars |>
+    purrr::map(units) |>
+    purrr::map_lgl(units::ud_are_convertible, "umol / m^2 / s / Pa") |>
+    any()
+  
+    if (xx) {
+      
+      message(
+        "
+      It looks like one or more of the conductance values is provided in units 
+      of 'umol / m^2 / s / Pa' or a unit that can be converted to it. This was 
+      the default in photosynthesis (<= 2.0.3), but we switched to 
+      'mol / m^2 / s' because these units are morely widely used in plant 
+      ecophysiology. 
+      
+      To convert, use this code with your desired temperature and pressure:
+      g = units::set_units(1, umol / m^2 / s / Pa)   
+      P = units::set_units(101.3246, kPa)
+      Temp = set_units(298.15, K) 
+      gunit::convert_conductance(g, P = P, Temp = Temp)$`mol/m^2/s`
+      
+      "
+      )
+      stop("Incorrect conductance units in leaf_par()", call. = FALSE)
+    }
+  
+  invisible()
+  
+}

data/R/make_parameters.R

@@ -0,0 +1,426 @@
+#' Make lists of parameters for `photosynthesis`
+#'
+#' @param replace A named list of parameters to replace defaults.
+#' If `NULL`, defaults will be used.
+#'
+#' @name make_parameters
+#'
+#' @encoding UTF-8
+
+NULL
+
+#' make_anypar
+#' @inheritParams make_parameters
+#' @inheritParams parameter_names
+#' @noRd
+make_anypar = function(which, replace, use_tealeaves) {
+
+  which = match.arg(which, choices = get_par_types())
+  
+  # Message about new conductance model ----
+  message_experimental(replace)
+  
+  # Defaults -----
+  obj = make_default_parameter_list(
+    which = which,
+    use_tealeaves = use_tealeaves
+  )
+  
+  # Special procedures for constants ---
+  if (which == "constants") {
+    
+    if ("f_nu" %in% names(replace)) {
+      stopifnot(is.function(replace$f_nu))
+      obj$f_nu = replace$f_nu
+      replace$f_nu = NULL
+    }
+    
+    if ("f_sh" %in% names(replace)) {
+      stopifnot(is.function(replace$f_sh))
+      obj$f_sh = replace$f_sh
+      replace$f_sh = NULL
+    }
+    
+  }
+
+  # Special procedures for enviro_par ----
+  if (which == "enviro") {
+    
+    if ("T_sky" %in% names(replace)) {
+      if (is.function(replace$T_sky)) {
+        obj$T_sky = replace$T_sky
+        replace$T_sky = NULL
+      }
+    }
+    
+    par_equiv = data.frame(
+      tl = c("S_sw"),
+      ph = c("PPFD")
+    )
+    
+    if (any(purrr::map_lgl(replace[par_equiv$tl], ~ !is.null(.x)))) {
+      par_equiv %>%
+        dplyr::filter(.data$tl %in% names(replace)) %>%
+        dplyr::transmute(message = stringr::str_c(
+          "\nIn `replace = list(...)`,
+             tealeaves parameter ", .data$tl,
+          " is not replacable. Use ", .data$ph, " instead."
+        )) %>%
+        dplyr::pull(.data$message) %>%
+        stringr::str_c(collapse = "\n") %>%
+        stop(call. = FALSE)
+    }
+    
+  }
+  
+  # Special procedures for leaf_par ----
+  if (which == "leaf" & use_tealeaves) {
+    
+    par_equiv = get_par_equiv()
+    
+    # Some equivalencies require additional parameters. Therefore leaving
+    # those parameter values empty
+    tl_placeholders = photosynthesis::photo_parameters |>
+      dplyr::filter(.data$R %in% par_equiv$tl) |>
+      dplyr::mutate(units = stringr::str_replace(units, "none", "1")) |>
+      split(~ R) |>
+      purrr::map(function(.y) {
+        a = 0
+        units(a) = as_units(.y[["units"]])
+        a
+      })
+    obj[names(tl_placeholders)] = tl_placeholders
+    
+    if (!is.null(replace)) {
+      if (!is.null(replace$T_leaf)) {
+        warning("replace$T_leaf ignored when use_tealeaves is TRUE")
+        replace$T_leaf = NULL
+      }
+      
+      
+      if (any(purrr::map_lgl(replace[par_equiv$tl], ~ !is.null(.x)))) {
+        par_equiv %>%
+          dplyr::filter(.data$tl %in% names(replace)) %>%
+          dplyr::transmute(message = stringr::str_c(
+            "\nIn `replace = list(...)`,
+             tealeaves parameter ", .data$tl, " is not replacable. Use ",
+            .data$ph, " instead."
+          )) %>%
+          dplyr::pull(.data$message) %>%
+          stringr::str_c(collapse = "\n") %>%
+          stop(call. = FALSE)
+      }
+    }
+  }
+  
+  # Replace defaults ----
+  obj %<>% replace_defaults(replace)
+  
+  # Assign class and return ----
+  switch(
+    which,
+    bake = photosynthesis::bake_par(obj),
+    constants = photosynthesis::constants(obj, use_tealeaves),
+    enviro = photosynthesis::enviro_par(obj, use_tealeaves),
+    leaf = photosynthesis::leaf_par(obj, use_tealeaves),
+  )
+
+}
+  
+#' make_leafpar
+#' @rdname make_parameters
+#'
+#' @inheritParams photosynthesis
+#'
+#' @return
+#'
+#' `make_leafpar`: An object inheriting from class [leaf_par()]\cr
+#' `make_enviropar`: An object inheriting from class [enviro_par()]\cr
+#' `make_bakepar`: An object inheriting from class [bake_par()]\cr
+#' `make_constants`: An object inheriting from class [constants()]
+#'
+#' @details
+#'
+#' **Constants:**
+#' ```{r, echo=FALSE}
+#'  make_photo_parameter_table(type == "constants", !tealeaves)
+#' ```
+#' 
+#' **Baking (i.e. temperature response) parameters:**
+#' ```{r, echo=FALSE}
+#'  make_photo_parameter_table(type == "bake", !tealeaves)
+#' ```
+#' 
+#' **Environment parameters:**
+#' ```{r, echo=FALSE}
+#'  make_photo_parameter_table(type == "enviro", !tealeaves)
+#' ```
+#'
+#' **Leaf parameters:**
+#' ```{r, echo=FALSE}
+#'  make_photo_parameter_table(type == "leaf", !tealeaves, 
+#'                             is.na(note) | note != "optional")
+#' ```
+#'
+#' If `use_tealeaves = TRUE`, additional parameters are:
+#'
+#' **Constants:**
+#' ```{r, echo=FALSE}
+#'  make_photo_parameter_table(type == "constants", tealeaves)
+#' ```
+#' 
+#' **Baking (i.e. temperature response) parameters:**
+#' ```{r, echo=FALSE}
+#'  make_photo_parameter_table(type == "bake", tealeaves)
+#' ```
+#' 
+#' **Environment parameters:**
+#' ```{r, echo=FALSE}
+#'  make_photo_parameter_table(type == "enviro", tealeaves)
+#' ```
+#'
+#' **Leaf parameters:**
+#' ```{r, echo=FALSE}
+#'  make_photo_parameter_table(type == "leaf", tealeaves)
+#' ```
+#'
+#' **Optional leaf parameters:**
+#'
+#' ```{r, echo=FALSE}
+#'  make_photo_parameter_table(type == "leaf", note == "optional")
+#' ```
+#'
+#' @references
+#'
+#' Buckley TN and Diaz-Espejo A. 2015. Partitioning changes in photosynthetic
+#' rate into contributions from different variables. Plant, Cell & Environment
+#' 38: 1200-11.
+#'
+#' @examples
+#' bake_par = make_bakepar()
+#' constants = make_constants(use_tealeaves = FALSE)
+#' enviro_par = make_enviropar(use_tealeaves = FALSE)
+#' leaf_par = make_leafpar(use_tealeaves = FALSE)
+#'
+#' leaf_par = make_leafpar(
+#'   replace = list(
+#'     g_sc = set_units(0.3, mol / m^2 / s),
+#'     V_cmax25 = set_units(100, umol / m^2 / s)
+#'   ), use_tealeaves = FALSE
+#' )
+#' @export
+#' @md
+
+make_leafpar = function(replace = NULL, use_tealeaves) {
+
+  make_anypar("leaf", replace = replace, use_tealeaves = use_tealeaves)
+  
+}
+
+#' make_enviropar
+#' @rdname make_parameters
+#' @export
+
+make_enviropar = function(replace = NULL, use_tealeaves) {
+
+  make_anypar("enviro", replace = replace, use_tealeaves = use_tealeaves)
+
+}
+
+#' make_bakepar
+#' @rdname make_parameters
+#' @export
+
+make_bakepar = function(replace = NULL) {
+
+  make_anypar("bake", replace = replace, use_tealeaves = FALSE)
+  
+}
+
+#' make_constants
+#' @rdname make_parameters
+#' @export
+
+make_constants = function(replace = NULL, use_tealeaves) {
+
+  make_anypar("constants", replace = replace, use_tealeaves = use_tealeaves)
+  
+}
+
+#' Character vector of acceptable parameter types
+#' @noRd
+get_par_types = function() {
+  c("bake", "constants", "enviro", "leaf")
+}
+
+#' Make default parameter list
+#' @inheritParams parameter_names
+#' @noRd
+make_default_parameter_list = function(which, use_tealeaves) {
+  
+  which = which |>
+    match.arg(get_par_types())
+  
+  default_parameter_list = photosynthesis::photo_parameters |>
+    dplyr::filter(
+      .data$type == which, 
+      !.data$temperature_response,
+      if (!use_tealeaves) {!.data$tealeaves} else TRUE,
+    ) |>
+    dplyr::mutate(units = stringr::str_replace(units, "none", "1")) |>
+    split(~ R) |>
+    purrr::map(function(.x) {
+      if(is.na(.x$default)) {
+        if (.x$note == "optional") {
+          a = numeric(0)
+          units(a) = as_units(.x$units)
+          return(a)
+        }
+        if (.x$note == "calculated") {
+          get_f_parameter(.x$R)
+        }
+      } else {
+        units(.x$default) = as_units(.x$units)
+        return(.x$default)
+      }
+    })
+  
+  default_parameter_list
+  
+}
+
+#' Check parameter names
+#' @inheritParams set_parameter_units
+#' @inheritParams parameter_names
+#' @noRd
+check_parameter_names = function(.x, which, use_tealeaves) {
+  
+  stopifnot(is.list(.x))
+  
+  nms = parameter_names(which, use_tealeaves = use_tealeaves)
+  
+  # Don't fail check if .x is missing tealeaves parameter equivalents
+  nms1 = nms[!(nms %in% get_par_equiv()[, "tl"])]
+  if (which == "leaf" & use_tealeaves) nms1 = nms1[!(nms1 == "T_leaf")]
+  
+  if (!all(nms1 %in% names(.x))) {
+    nms1[!(nms1 %in% names(.x))] |>
+      stringr::str_c(collapse = ", ") %>%
+      glue::glue("{x} not in parameter names required for {which}",
+                 x = ., which = which
+      ) |>
+      stop()
+  }
+  
+  nms
+  
+}
+
+#' Set parameter units
+#' @param .x list of parameters to set units
+#' @param ... arguments passed to dplyr::filter()
+#' @noRd
+
+set_parameter_units = function(.x, ...) {
+  
+  photosynthesis::photo_parameters |>
+    dplyr::filter(...) |>
+    dplyr::mutate(units = stringr::str_replace(units, "none", "1")) |>
+    split(~ R) |>
+    purrr::map(function(.y) {
+      v = .x[[.y$R]]
+      if (is.function(v)) {
+        v
+      } else {
+        a = if (is.null(v)) {0} else {v}
+        units(a) = as_units(.y$units)
+        a
+      }
+    })
+  
+}
+
+#' Assert parameter bounds
+#' @param .x list of parameters
+#' @param ... arguments passed to dplyr::filter()
+#' @noRd
+assert_parameter_bounds = function(.x, ...) {
+  
+  photosynthesis::photo_parameters |>
+    dplyr::filter(...) |>
+    dplyr::mutate(units = stringr::str_replace(units, "none", "1")) |>
+    split(~ R) |>
+    purrr::map_lgl(function(.y) {
+      if (
+        length(.x[[.y$R]]) == 0L |
+        is.function(.x[[.y$R]]) | 
+        is.na(.y$lower) | 
+        is.na(.y$upper)
+      ) {
+        TRUE
+      } else {
+        units(.y$lower) = as_units(.y$units)
+        units(.y$upper) = as_units(.y$units)
+        all(.x[[.y$R]] >= .y$lower & .x[[.y$R]] <= .y$upper)
+      }
+    }) |>
+    all() |>
+    checkmate::assert_true()
+  
+}
+
+#' Message about experimental parameters
+#' @inheritParams replace
+#' @noRd
+message_experimental = function(replace) {
+  experimental_leafpar = c(
+    "delta_ias_lower",
+    "delta_ias_upper",
+    "A_mes_A",
+    "g_liqc"
+  )
+  if (any(names(replace) %in% experimental_leafpar)) {
+    message(
+      "
+      It looks like you are using the new CO2 conductance model.
+      
+      As of version 2.1.0, the new CO2 conductance model is experimental and
+      may change in new releases. Use with caution.
+      ")
+  }
+  invisible()
+}
+
+#' Replace default parameters
+#'
+#' @param obj List of default values
+#' @param replace List of replacement values
+#' @noRd
+
+replace_defaults = function(obj, replace) {
+  if (!is.null(replace)) {
+    stopifnot(is.list(replace))
+    stopifnot(all(sapply(replace, inherits, what = "units")))
+    stopifnot(all(sapply(replace, is.numeric)))
+    x = names(replace)
+    if (any(!x %in% names(obj))) {
+      warning(sprintf("The following parameters in 'replace' were not
+                      recognized:\n%s", paste0(x[!x %in% names(obj)],
+        collapse = "\n"
+      )))
+      x %<>% .[. %in% names(obj)]
+    }
+    obj[x] = replace[x]
+  }
+
+  obj
+}
+
+#' Get data.frame of equivalent parameters between tealeaves and photosynthesis
+#' @noRd
+get_par_equiv = function() {
+  data.frame(
+    tl = c("g_sw", "g_uw", "logit_sr"),
+    ph = c("g_sc", "g_uc", "k_sc")
+  )
+}

data/R/models.R

@@ -0,0 +1,109 @@
+#' Get default model
+#' 
+#' @rdname models
+#' 
+#' @description 
+#' 
+#' `r lifecycle::badge("experimental")`
+#' 
+#' Get the name of the default model used for different plant ecophysiological data analysis methods implemented in **photosynthesis**. Currently only used for [fit_aq_response2()] and [fit_r_light2()].
+#' 
+#' @inheritParams fit_photosynthesis
+#' 
+#' @return A character string with name of model.
+#' 
+#' @examples 
+#' get_default_model("aq_response")
+#' get_default_model("r_light")
+#' 
+#' @md
+#' @export
+get_default_model = function(.photo_fun) {
+  .photo_fun = match.arg(.photo_fun, get_function_types())
+  switch(
+    .photo_fun,
+    aq_response = "marshall_biscoe_1980",
+    r_light = "walker_ort_2015"
+  )
+}
+
+#' @rdname models
+#' @export
+get_all_models = function(method) {
+  match.arg(method, get_function_types())
+  switch(
+    method,
+    aq_response = c("marshall_biscoe_1980", "photoinhibition"),
+    r_light = c("kok_1956", "walker_ort_2015", "yin_etal_2011")
+  )
+}
+
+#' @rdname models
+#' @description
+#' **Light response models:**
+#' 
+#' * `marshall_biscoe_1980()`: Non-rectangular hyperbolic model of light responses
+#' * `photoinhibition()`: Non-rectangular hyperbolic model of light responses with photoinhibition of `k_sat` at increasing Q_abs
+#'
+#' @param Q_abs Absorbed light intensity (\eqn{\mu}mol m\eqn{^{-2}} s\eqn{^{-1}})
+#' @param k_sat Light saturated rate of process k
+#' @param phi_J Quantum efficiency of process k
+#' @param theta_J Curvature of the light response
+#' @param b_inh Inhibition parameter
+#' @md
+#' 
+#' @export
+marshall_biscoe_1980 = function(Q_abs, k_sat, phi_J, theta_J) {
+  
+  ((k_sat + phi_J * Q_abs) - 
+     sqrt((k_sat + phi_J * Q_abs) ^ 2 - 4 * k_sat * phi_J * Q_abs * theta_J)) / 
+  (2 * theta_J)
+
+}
+
+#' @rdname models
+#' @export
+photoinhibition = function(Q_abs, k_sat, phi_J, theta_J, b_inh) {
+  k_sat1 = k_sat - b_inh * Q_abs
+  marshall_biscoe_1980(Q_abs, k_sat1, phi_J, theta_J) 
+}
+
+#' Variables required for **photosynthesis** models
+#' 
+#' @inheritParams fit_photosynthesis
+#' @export
+required_variables = function(.model, quiet) {
+  
+  .model = match.arg(.model, get_function_types() |>
+                       purrr::map(get_all_models) |>
+                       unlist())
+  all_vars = list(
+    .A = "net CO2 assimilation rate (umol/m^2/s)",
+    .C = "intercellular or chloroplastic CO2 concentration (umol/mol)",
+    .phiPSII = "quantum efficiency of PSII electron transport (mol / mol)",
+    .Q = "irradiance (umol/m^2/s)"
+  )
+  
+  model_vars = switch(
+    .model,
+    kok_1956 = all_vars[c(".A", ".Q")],
+    marshall_biscoe_1980 = all_vars[c(".A", ".Q")],
+    photoinhibition = all_vars[c(".A", ".Q")],
+    walker_ort_2015 = all_vars[c(".A", ".C", ".Q")],
+    yin_etal_2011 = all_vars[c(".A", ".phiPSII", ".Q")]
+  ) 
+  
+  if (!quiet) {
+    cat(.model, "\n")
+    purrr::iwalk(model_vars, ~ {cat(.y, ": ", .x, "\n")})
+  }
+  
+  invisible(names(model_vars))
+  
+}
+
+#' Vector of method types
+#' @noRd
+get_function_types = function() {
+  c("aq_response", "r_light")
+}

data/R/parameter_names.R

@@ -0,0 +1,21 @@
+#' Get vector of parameter names
+#'
+#' @inheritParams photosynthesis
+#' @param which A character string indicating which parameter names to retrieve: "leaf", "enviro", "bake", or "constants". Partial matching allowed.
+#'
+#' @returns 
+#' 
+#' A character vector with parameter names associated with each type, "leaf", "enviro", "bake", or "constants".
+#' 
+#' @examples
+#'
+#' parameter_names("leaf", use_tealeaves = FALSE)
+#' @export
+parameter_names = function(which, use_tealeaves) {
+  
+  which |>
+    match.arg(get_par_types()) |>
+    make_default_parameter_list(use_tealeaves) |>
+    names()
+
+}

data/R/photosynthesis-package.R

@@ -0,0 +1,33 @@
+#' `photosynthesis` package
+#'
+#' Tools for Plant Ecophysiology & Modeling
+#'
+#' See the README on
+#' [GitHub](https://github.com/cdmuir/photosynthesis)
+#'
+#' @name photosynthesis-package
+#' @importFrom ggplot2 ggplot
+#' @importFrom magrittr %>% %<>%
+#' @importFrom minpack.lm nlsLM nls.lm.control
+#' @importFrom methods is
+#' @importFrom nlme lmList
+#' @importFrom rlang .data
+#' @importFrom stats coef lm optim plogis resid rnorm
+#' @importFrom units as_units drop_units set_units
+#' @keywords internal
+"_PACKAGE"
+NULL
+
+## quiets concerns of R CMD check re: the .'s that appear in pipelines
+if (getRversion() >= "2.15.1") utils::globalVariables(c("."))
+
+## quiets concerns of R CMD check re: units
+utils::globalVariables(c(
+  ".A", ".C", ".phiPSII", ".Q", ".Qabs", "degreeC", "g", "hPa", "J", "K", "kg", 
+  "kJ", "kPa", "m", "mol", "mmol", "normal", "Pa", "PPFD", "s", "umol", "W"
+))
+
+## quiets concerns of R CMD check about using ::: operator
+.get_Dx <- utils::getFromNamespace(".get_Dx", "tealeaves")
+.get_gbw <- utils::getFromNamespace(".get_gbw", "tealeaves")
+.get_ps <- utils::getFromNamespace(".get_ps", "tealeaves")

data/R/photosynthesis.R

@@ -0,0 +1,627 @@
+#' Simulate C3 photosynthesis
+#'
+#' `photosynthesis`: simulate C3 photosynthesis over multiple parameter sets
+#'
+#' @param leaf_par A list of leaf parameters inheriting class `leaf_par`. This can be generated using the `make_leafpar` function.
+#'
+#' @param enviro_par A list of environmental parameters inheriting class `enviro_par`. This can be generated using the `make_enviropar` function.
+#'
+#' @param bake_par A list of temperature response parameters inheriting class `bake_par`. This can be generated using the `make_bakepar` function.
+#'
+#' @param constants A list of physical constants inheriting class `constants`. This can be generated using the `make_constants` function.
+#'
+#' @param use_tealeaves Logical. Should leaf energy balance be used to calculate leaf temperature (T_leaf)? If TRUE, [`tleaf()`][tealeaves::tleaves] calculates T_leaf. If FALSE, user-defined T_leaf is used. Additional parameters and constants are required, see [make_parameters()].
+#'
+#' @param progress Logical. Should a progress bar be displayed?
+#'
+#' @param quiet Logical. Should messages be displayed?
+#'
+#' @param assert_units Logical. Should parameter `units` be checked? The function is faster when FALSE, but input must be in correct units or else results will be incorrect without any warning.
+#'
+#' @param check Logical. Should arguments checks be done? Default is TRUE.
+#' 
+#' @param parallel Logical. Should parallel processing be used via [furrr::future_map()]?
+#' 
+#' @param use_legacy_version Logical. Should legacy model (<2.1.0) be used? See [NEWS](https://github.com/cdmuir/photosynthesis/blob/master/NEWS.md) for further information. Default is FALSE. 
+#'
+#' @return
+#' A data.frame with the following `units` columns \cr
+#' 
+#' **Inputs:**
+#' ```{r, echo=FALSE}
+#'  make_photo_parameter_table(!temperature_response, !tealeaves)
+#' ```
+#' **Baked Inputs:** 
+#' ```{r, echo=FALSE}
+#'  make_photo_parameter_table(temperature_response, !tealeaves)
+#' ```
+#'
+#' \tabular{ll}{
+#'
+#' **Output:** \tab \cr
+#' \cr
+#' `A` \tab photosynthetic rate at `C_chl` (\eqn{\mu}mol CO2 / m\eqn{^2} / s) \cr
+#' `C_chl` \tab chloroplastic CO2 concentration where `A_supply` intersects `A_demand` (\eqn{mu}mol / mol) \cr
+#' `C_i` \tab intercellular CO2 concentration where `A_supply` intersects `A_demand` (\eqn{mu}mol / mol) \cr
+#' `g_tc` \tab total conductance to CO2 at `T_leaf` (mol / m\eqn{^2} / s)) \cr
+#' `value` \tab `A_supply` - `A_demand` (\eqn{\mu}mol / (m\eqn{^2} s)) at `C_chl` \cr
+#' `convergence` \tab convergence code (0 = converged)
+#' }
+#'
+#' @details
+#'
+#' `photo`: This function takes simulates photosynthetic rate using the Farquhar-von Caemmerer-Berry ([FvCB()]) model of C3 photosynthesis for single combined set of leaf parameters ([leaf_par()]), environmental parameters ([enviro_par()]), and physical constants ([constants()]). Leaf parameters are provided at reference temperature (25 °C) and then "baked" to the appropriate leaf temperature using temperature response functions (see [bake()]). \cr
+#' \cr
+#' `photosynthesis`: This function uses `photo` to simulate photosynthesis over multiple parameter sets that are generated using [`cross_df()`][purrr::cross]. \cr
+#'
+#' @examples
+#' # Single parameter set with 'photo'
+#'
+#' bake_par = make_bakepar()
+#' constants = make_constants(use_tealeaves = FALSE)
+#' enviro_par = make_enviropar(use_tealeaves = FALSE)
+#' leaf_par = make_leafpar(use_tealeaves = FALSE)
+#' photo(leaf_par, enviro_par, bake_par, constants,
+#'   use_tealeaves = FALSE
+#' )
+#'
+#' # Multiple parameter sets with 'photosynthesis'
+#'
+#' leaf_par = make_leafpar(
+#'   replace = list(
+#'     T_leaf = set_units(c(293.14, 298.15), "K")
+#'   ), use_tealeaves = FALSE
+#' )
+#' photosynthesis(leaf_par, enviro_par, bake_par, constants,
+#'   use_tealeaves = FALSE
+#' )
+#' @encoding UTF-8
+#'
+#' @export
+#' @md
+
+photosynthesis = function(
+    leaf_par, 
+    enviro_par, 
+    bake_par, 
+    constants,
+    use_tealeaves, 
+    progress = TRUE, 
+    quiet = FALSE,
+    assert_units = TRUE, 
+    check = TRUE,
+    parallel = FALSE,
+    use_legacy_version = FALSE
+) {
+  
+  # Check arguments ----
+  checkmate::assert_flag(check)
+  
+  if (check) {
+    checkmate::assert_class(bake_par, "bake_par")
+    checkmate::assert_class(constants, "constants")
+    checkmate::assert_class(enviro_par, "enviro_par")
+    checkmate::assert_class(leaf_par, "leaf_par")
+    checkmate::assert_flag(use_tealeaves)
+    checkmate::assert_flag(quiet)
+    checkmate::assert_flag(assert_units)
+    checkmate::assert_flag(parallel)
+    checkmate::assert_flag(use_legacy_version)
+  }
+  
+  # Message about legacy version ----
+  notify_users(quiet = quiet, leaf_par = leaf_par)
+  
+  T_air = NULL
+  if (!use_tealeaves && !is.null(enviro_par$T_air)) {
+    if (!quiet) {
+      message(glue::glue("Both air and leaf temperature are provided and fixed: T_air = {T_air}; T_leaf = {T_leaf}",
+                         T_air = enviro_par$T_air,
+                         T_leaf = leaf_par$T_leaf
+      ))
+    }
+    T_air = enviro_par$T_air
+  }
+  
+  # Assert units ----
+  if (assert_units) {
+    bake_par %<>% photosynthesis::bake_par()
+    constants %<>% photosynthesis::constants(use_tealeaves)
+    enviro_par %<>% photosynthesis::enviro_par(use_tealeaves)
+    leaf_par %<>% photosynthesis::leaf_par(use_tealeaves)
+    if (!is.null(T_air)) enviro_par$T_air = set_units(T_air, K)
+  }
+  
+  # Make parameter sets ----
+  pars = make_parameter_sets(leaf_par, enviro_par, bake_par, constants)
+  
+  # Solve ----
+  soln = solve_for_photosynthesis(
+    pars,
+    bake_par, 
+    constants, 
+    use_tealeaves,
+    progress,
+    quiet,
+    parallel,
+    use_legacy_version
+  )
+  
+  # Return ----
+  soln
+  
+}
+
+#' Make parameter sets for [photosynthesis()]
+#' @inheritParams photosynthesis
+#' @noRd
+make_parameter_sets = function(
+    leaf_par, 
+    enviro_par, 
+    bake_par, 
+    constants
+) {
+  
+  pars = c(
+    purrr::keep(leaf_par, ~ length(.x) > 0), 
+    purrr::keep(enviro_par, ~ length(.x) > 0)
+  ) |>
+    purrr::map(~ {if (is.function(.x)) {list(.x)} else {.x}}) |>
+    expand.grid()
+  
+  ## Add units back
+  # function_pars = apply(pars, 2, function(.x) any(sapply(.x, is.function)))
+  # function_par_cols = pars[, function_pars]
+  # pars = pars %>% 
+  #   set_parameter_units(.data$R %in% colnames(.)[!function_pars]) |>
+  #   tibble::as_tibble() |>
+  #   dplyr::bind_cols(function_par_cols)
+  
+  pars
+  
+}
+
+#' Solve for C_chl and A for each parameter set within [photosynthesis()]
+#' @inheritParams photosynthesis
+#' @noRd
+solve_for_photosynthesis = function(
+    pars,
+    bake_par, 
+    constants, 
+    use_tealeaves,
+    progress,
+    quiet,
+    parallel,
+    use_legacy_version
+) {
+  
+  if (!quiet) {
+    glue::glue("\nSolving for photosynthetic rate from {n} parameter set{s} ...",
+               n = nrow(pars), s = dplyr::if_else(length(pars) > 1, "s", "")
+    ) %>%
+      crayon::green() %>%
+      message(appendLF = FALSE)
+  }
+  
+  if (progress && !parallel) pb = progress::progress_bar$new(total = nrow(pars))
+  
+  soln = if (parallel) {
+    pars %>%
+      split(~ seq_len(nrow(.))) |>
+      furrr::future_map_dfr(
+        solve_for_photosynthesis_set, 
+        bake_par = bake_par,
+        constants = constants,
+        use_tealeaves = use_tealeaves,
+        use_legacy_version = use_legacy_version,
+        .progress = progress
+      )
+  } else {
+    pars %>%
+      split(~ seq_len(nrow(.))) |>
+      purrr::map_dfr(~ {
+        ret = solve_for_photosynthesis_set(
+          pars = .x,
+          bake_par = bake_par,
+          constants = constants,
+          use_tealeaves = use_tealeaves,
+          use_legacy_version = use_legacy_version
+        )
+        if (progress) pb$tick()
+        ret
+      })
+    }
+  
+  soln
+  
+}
+
+#' Solve for C_chl and A for a single parameter set within [photosynthesis()]
+#' @inheritParams photosynthesis
+#' @noRd
+solve_for_photosynthesis_set = function(
+    pars,
+    bake_par, 
+    constants, 
+    use_tealeaves,
+    use_legacy_version
+) {
+  
+  lx = intersect(
+    colnames(pars), 
+    parameter_names("leaf", use_tealeaves = use_tealeaves)
+  )
+  
+  ex = intersect(
+    colnames(pars),
+    parameter_names("enviro", use_tealeaves = use_tealeaves)
+  )
+  
+  # This would cause an error is element was list with multiple elements,
+  # but this structure shouldn't occur by this point
+  lp = as.list(pars)[lx] |>
+    lapply(function(.x) if (is.list(.x)) {.x[[1]]} else .x)
+  
+  ep = as.list(pars)[ex] |>
+    lapply(function(.x) if (is.list(.x)) {.x[[1]]} else .x)
+
+  photo(lp, ep, bake_par, constants, use_tealeaves, quiet = TRUE,
+        assert_units = FALSE, check = FALSE,
+        use_legacy_version = use_legacy_version)
+  
+}
+
+#' Simulate C3 photosynthesis
+#' @description `photo`: simulate C3 photosynthesis over a single parameter set
+#' @rdname photosynthesis
+#'
+#' @param check Logical. Should arguments checks be done? This is intended to be disabled when [photo()] is called from [photosynthesis()] Default is TRUE.
+#'
+#' @param prepare_for_tleaf Logical. Should arguments additional calculations for [`tleaf()`][tealeaves::tleaves]? This is intended to be disabled when [photo()] is called from [photosynthesis()]. Default is `use_tealeaves`.
+#'
+#' @export
+
+photo = function(
+    leaf_par, 
+    enviro_par, 
+    bake_par, 
+    constants,
+    use_tealeaves, 
+    quiet = FALSE, 
+    assert_units = TRUE,
+    check = TRUE, 
+    prepare_for_tleaf = use_tealeaves,
+    use_legacy_version = FALSE
+  ) {
+  
+  # Check arguments ----
+  checkmate::assert_flag(check)
+
+  if (check) {
+    checkmate::assert_class(bake_par, "bake_par")
+    checkmate::assert_class(constants, "constants")
+    checkmate::assert_class(enviro_par, "enviro_par")
+    checkmate::assert_class(leaf_par, "leaf_par")
+    checkmate::assert_flag(use_tealeaves)
+    checkmate::assert_flag(quiet)
+    checkmate::assert_flag(assert_units)
+    checkmate::assert_flag(prepare_for_tleaf)
+    checkmate::assert_flag(use_legacy_version)
+  }
+
+  # Message about legacy version ----
+  notify_users(quiet = quiet, leaf_par = leaf_par)
+  
+  T_air = NULL
+  if (!use_tealeaves && !is.null(enviro_par$T_air)) {
+    if (!quiet) {
+      message(glue::glue("Both air and leaf temperature are provided and fixed: T_air = {T_air}; T_leaf = {T_leaf}",
+        T_air = enviro_par$T_air,
+        T_leaf = leaf_par$T_leaf
+      ))
+    }
+    T_air = enviro_par$T_air
+  }
+
+  # Set units and bake ----
+  if (assert_units) {
+    bake_par %<>% photosynthesis::bake_par()
+    constants %<>% photosynthesis::constants(use_tealeaves)
+    enviro_par %<>% photosynthesis::enviro_par(use_tealeaves)
+    leaf_par %<>% photosynthesis::leaf_par(use_tealeaves)
+    if (!is.null(T_air)) enviro_par$T_air = set_units(T_air, K)
+  }
+
+  # Calculate T_leaf using energy balance ----
+  if (use_tealeaves) {
+    leaf_par %<>% add_Tleaf_photo(enviro_par, constants, prepare_for_tleaf)
+    # Hack to add E. Should do this better and for all tealeaves calculated
+    # values
+    E_out = leaf_par$E 
+  }
+  
+  leaf_par %<>% bake(enviro_par, bake_par, constants, assert_units = FALSE)
+
+  pars = c(leaf_par, enviro_par, constants) %>%
+    purrr::map_if(~ inherits(.x, "units"), drop_units)
+  if (!use_tealeaves && is.null(pars$T_air)) pars$T_air = pars$T_leaf
+
+  # Find intersection between photosynthetic supply and demand curves -----
+  soln = find_A(pars, quiet, use_legacy_version)
+
+  # Check results -----
+  if (soln$convergence == 1) {
+    "stats::uniroot did not converge, NA returned. Inspect parameters carefully." %>%
+      crayon::red() %>%
+      message()
+  }
+
+  # Return -----
+  # This is a hack needed for `photosynthesis()` because leaf_par and enviro_par
+  # are both passed from pars = c(leaf_par, enviro_par), so they have redundant
+  # information. This checks that everything is identical, then gets rid of
+  # redundant parameters.
+  shared_pars = intersect(names(leaf_par), names(enviro_par))
+  checkmate::assert_true(all(unlist(leaf_par[shared_pars]) ==
+    unlist(enviro_par[shared_pars])))
+  leaf_par[shared_pars] = NULL
+
+  soln = c(
+    soln,
+    purrr::keep(leaf_par, ~ length(.x) > 0 & !is.function(.x)),
+    purrr::keep(enviro_par, ~ length(.x) > 0 & !is.function(.x)),
+    purrr::keep(bake_par, ~ length(.x) > 0 & !is.function(.x)),
+    purrr::keep(constants, ~ length(.x) > 0 & !is.function(.x))
+  ) |>
+    as.data.frame()
+  
+  soln$C_chl %<>% set_units(umol / mol)
+  soln$g_tc %<>% set_units(mol / m^2 / s)
+  soln$A %<>% set_units(umol / m^2 / s)
+  soln$C_i = set_units(soln$C_air - soln$A / soln$g_sc, umol/mol)
+
+  # I should make this for all additional tealeaves calculated value
+  if (use_tealeaves) soln$E = E_out
+  
+  soln
+  
+}
+
+#' Calculate leaf temperature using [tealeaves::tleaf()]
+#' @inheritParams photo
+#' @noRd
+add_Tleaf_photo = function(leaf_par, enviro_par, constants, prepare_for_tleaf) {
+  
+  leaf_par1 = leaf_par
+  constants1 = constants
+  
+  if (prepare_for_tleaf) {
+    enviro_par$S_sw = set_units(enviro_par$E_q * enviro_par$PPFD /
+                                  enviro_par$f_par, W / m^2)
+    leaf_par$g_sw = set_units(
+      constants$D_w0 / constants$D_c0 * leaf_par$g_sc,
+      mol / m^2 / s
+    )
+    leaf_par$g_uw = set_units(
+      constants$D_w0 / constants$D_c0 * leaf_par$g_uc,
+      mol / m^2 / s
+    )
+    
+    leaf_par1$logit_sr = if (is(leaf_par$k_sc, "units")) {
+      stats::qlogis(leaf_par$k_sc / (set_units(1) + leaf_par$k_sc))
+    } else {
+      stats::qlogis(leaf_par$k_sc / (1 + leaf_par$k_sc))
+    }
+    
+    # Need this until tealeaves changes these parameters for consistency
+    leaf_par1$g_sw = if (is(leaf_par$g_sw, "units")) {
+      leaf_par$g_sw |>
+        gunit::convert_conductance(P = enviro_par$P, R = constants$R) |>
+        magrittr::extract2("umol/m^2/s/Pa")
+    } else {
+      leaf_par$g_sw / enviro_par$P * 1000
+    }
+    
+    leaf_par1$g_uw = if (is(leaf_par$g_uw, "units")) {
+      leaf_par$g_uw |>
+        gunit::convert_conductance(P = enviro_par$P, R = constants$R) |>
+        magrittr::extract2("umol/m^2/s/Pa")
+    } else {
+      leaf_par$g_uw / enviro_par$P * 1000
+    }
+    
+    
+    constants1$nu_constant = constants$f_nu
+    constants1$sh_constant = constants$f_sh
+    constants1$f_nu = constants1$f_sh = NULL
+    constants1$s = constants1$sigma
+    constants1$sigma = NULL
+  }
+  
+  tl = tealeaves::tleaf(
+    leaf_par = leaf_par1, 
+    enviro_par = enviro_par,
+    constants = constants1, 
+    quiet = TRUE,
+    set_units = TRUE
+  ) %>% 
+    dplyr::rename(
+      tealeaves_convergence = "convergence",
+      tealeaves_value = "value"
+    )
+  leaf_par$T_leaf = tl$T_leaf
+  leaf_par$E = tl$E
+  
+  leaf_par
+  
+}
+
+supply_minus_demand = function(C_chl, unitless_pars, use_legacy_version) {
+  supply = A_supply(C_chl, unitless_pars, unitless = TRUE, use_legacy_version)
+  demand = A_demand(C_chl, unitless_pars, unitless = TRUE)
+  supply - demand
+}
+
+find_A = function(unitless_pars, quiet, use_legacy_version) {
+
+    if (!quiet) {
+    "\nSolving for C_chl ..." %>%
+      crayon::green() %>%
+      message(appendLF = FALSE)
+  }
+
+  fit = tryCatch(
+    {
+      Cchl_upper = max(c(unitless_pars$gamma_star, unitless_pars$C_air))
+      while (supply_minus_demand(Cchl_upper, unitless_pars, use_legacy_version) > 0) {
+        Cchl_upper = 2 * Cchl_upper
+      }
+      stats::uniroot(supply_minus_demand,
+        unitless_pars = unitless_pars, lower = 0.1,
+        upper = Cchl_upper, 
+        check.conv = TRUE, use_legacy_version = use_legacy_version
+      )
+    },
+    finally = {
+      fit = list(root = NA, f.root = NA, convergence = 1)
+    }
+  )
+
+  soln = data.frame(
+    C_chl = fit$root, value = fit$f.root,
+    convergence = dplyr::if_else(is.null(fit$convergence), 0, 1)
+  )
+
+  if (!quiet) {
+    " done" %>%
+      crayon::green() %>%
+      message()
+  }
+
+  soln$g_tc = .get_gtc(unitless_pars, unitless = TRUE, use_legacy_version)
+  soln$A = A_supply(soln$C_chl, unitless_pars, unitless = TRUE,
+                    use_legacy_version)
+
+  soln
+}
+
+#' CO2 supply and demand function (mol / m^2 s)
+#'
+#' This function is not intended to be called by users directly.
+#' 
+#' @inheritParams photosynthesis
+#' 
+#' @param C_chl Chloroplastic CO2 concentration in Pa of class `units`
+#' @param pars Concatenated parameters (`leaf_par`, `enviro_par`, and `constants`)
+#' @param unitless Logical. Should `units` be set? The function is faster when FALSE, but input must be in correct units or else results will be incorrect without any warning.
+#'
+#' @return Value in mol / (m^2 s) of class `units`
+#'
+#' @details
+#'
+#' **Supply function:**
+#' \cr
+#' \deqn{A = g_\mathrm{tc} (C_\mathrm{air} - C_\mathrm{chl})}{A = g_tc (C_air - C_chl)}
+#'
+#' **Demand function:**
+#' \cr
+#' \deqn{A = (1 - \Gamma* / C_\mathrm{chl}) \mathrm{min}(W_\mathrm{carbox}, W_\mathrm{regen}, W_\mathrm{tpu}) - R_\mathrm{d}}{A = (1 - \Gamma* / C_chl) min(W_carbox, W_regen, W_tpu) - R_d}
+#'
+#' \tabular{lllll}{
+#' *Symbol* \tab *R* \tab *Description* \tab *Units* \tab *Default*\cr
+#' \eqn{A} \tab `A` \tab photosynthetic rate \tab \eqn{\mu}mol CO2 / (m^2 s) \tab calculated \cr
+#' \eqn{g_\mathrm{tc}}{g_tc} \tab `g_tc` \tab total conductance to CO2 \tab \eqn{\mu}mol CO2 / (m\eqn{^2} s Pa) \tab [calculated][.get_gtc] \cr
+#' \eqn{C_\mathrm{air}}{C_air} \tab `C_air` \tab atmospheric CO2 concentration \tab Pa \tab 41 \cr
+#' \eqn{C_\mathrm{chl}}{C_chl} \tab `C_chl` \tab chloroplastic CO2 concentration \tab Pa \tab calculated\cr
+#' \eqn{R_\mathrm{d}}{R_d} \tab `R_d` \tab nonphotorespiratory CO2 release \tab \eqn{\mu}mol CO2 / (m\eqn{^2} s) \tab 2 \cr
+#' \eqn{\Gamma*} \tab `gamma_star` \tab chloroplastic CO2 compensation point \tab Pa \tab 3.743
+#' }
+#'
+#' @examples
+#' bake_par = make_bakepar()
+#' constants = make_constants(use_tealeaves = FALSE)
+#' enviro_par = make_enviropar(use_tealeaves = FALSE)
+#' leaf_par = make_leafpar(use_tealeaves = FALSE)
+#' leaf_par = bake(leaf_par, enviro_par, bake_par, constants)
+#' # Or bake with piping (need library(magrittr))
+#' # leaf_par %<>% bake(enviro_par, bake_par, constants)
+#' enviro_par$T_air = leaf_par$T_leaf
+#'
+#' pars = c(leaf_par, enviro_par, constants)
+#' C_chl = set_units(350, umol/mol)
+#'
+#' A_supply(C_chl, pars)
+#'
+#' A_demand(C_chl, pars)
+#' @export
+
+A_supply = function(C_chl, pars, unitless = FALSE, use_legacy_version = FALSE) {
+  g_tc = .get_gtc(pars, unitless, use_legacy_version)
+
+  if (unitless) {
+    As = g_tc * (pars$C_air - C_chl)
+  } else {
+    As = set_units(g_tc * (pars$C_air - C_chl), umol / m^2 / s)
+  }
+  As
+}
+
+#' A_demand
+#' @rdname A_supply
+#' @export
+
+A_demand = function(C_chl, pars, unitless = FALSE) {
+  if (unitless) {
+    Ad = (1 - pars$gamma_star / C_chl) * FvCB(C_chl, pars, unitless)$A - pars$R_d
+  } else {
+    Ad = set_units((set_units(1) - pars$gamma_star / C_chl) *
+      FvCB(C_chl, pars, unitless)$A - pars$R_d, umol / m^2 / s)
+  }
+
+  Ad
+}
+
+#' Check whether users supplied parameters to calculate g_ias and g_liq
+#' @noRd
+check_new_conductance = function(pars, baked) {
+  checkmate::assert_flag(baked)
+  if (baked) {
+    c("g_iasc_lower", "g_iasc_upper", "A_mes_A", "g_liqc") |>
+      purrr::map_lgl(function(.x, pars) {
+        length(pars[[.x]]) > 0 & all(!is.na(pars[[.x]]))
+      }, pars = pars) |>
+      all()
+  } else {
+    c("delta_ias_lower", "delta_ias_upper", "A_mes_A", "g_liqc25") |>
+      purrr::map_lgl(function(.x, pars) {
+        length(pars[[.x]]) > 0 & all(!is.na(pars[[.x]]))
+      }, pars = pars) |>
+      all()
+  }
+  
+}
+
+#' Notify users about important changes in \link[photosyntesis]
+#' @noRd
+notify_users = function(quiet, leaf_par) {
+  
+  if (!quiet) {
+    message("
+            
+  As of version 2.1.0, the CO2 conductance model changed slightly. 
+  To implement legacy version, use:
+  
+  `> photosynthesis(..., use_legacy_version = TRUE)`.")
+    
+    if (check_new_conductance(leaf_par, baked = FALSE)) {
+      message("
+  It looks like you provided parameters to calculate g_ias and g_liq.
+  The parameters g_mc and k_mc will be ignored and calculated from g_ias 
+  and g_liq. This is a new feature in version 2.1.0 and may change in the
+  near future. Inspect results carefully.
+  ")
+    }
+    
+  }
+  
+}

data/R/print_graphs.R

@@ -0,0 +1,132 @@
+#' Printing graphs to system
+#'
+#' @param data List of graphs
+#' @param path File path for printing our graphs. Use "./" to set to current
+#' working directory
+#' @param output_type Type of output file, jpeg or pdf
+#' @param height Height of jpegs
+#' @param width Width of jpegs
+#' @param res Resolution of jpegs
+#' @param units Units of height and width
+#' @param pdf_filename Filename for pdf option
+#' @param ... Further arguments for jpeg() and pdf()
+#'
+#' @return print_graphs creates graph files in current working directory
+#' from a list of graphs
+#' @importFrom grDevices dev.off
+#' @importFrom grDevices jpeg
+#' @importFrom grDevices pdf
+#' @importFrom graphics par
+#' @importFrom graphics plot
+#' @export
+#'
+#' @examples
+#' \donttest{
+#' # Read in your data
+#' # Note that this data is coming from data supplied by the package
+#' # hence the complicated argument in read.csv()
+#' # This dataset is a CO2 by light response curve for a single sunflower
+#' data <- read.csv(system.file("extdata", "A_Ci_Q_data_1.csv",
+#'   package = "photosynthesis"
+#' ))
+#'
+#' # Fit many AQ curves
+#' # Set your grouping variable
+#' # Here we are grouping by CO2_s and individual
+#' data$C_s <- (round(data$CO2_s, digits = 0))
+#'
+#' # For this example we need to round sequentially due to CO2_s setpoints
+#' data$C_s <- as.factor(round(data$C_s, digits = -1))
+#'
+#' # To fit one AQ curve
+#' fit <- fit_aq_response(data[data$C_s == 600, ],
+#'   varnames = list(
+#'     A_net = "A",
+#'     PPFD = "Qin"
+#'   )
+#' )
+#'
+#' # Print model summary
+#' summary(fit[[1]])
+#'
+#' # Print fitted parameters
+#' fit[[2]]
+#'
+#' # Print graph
+#' fit[[3]]
+#'
+#' # Fit many curves
+#' fits <- fit_many(
+#'   data = data,
+#'   varnames = list(
+#'     A_net = "A",
+#'     PPFD = "Qin",
+#'     group = "C_s"
+#'   ),
+#'   funct = fit_aq_response,
+#'   group = "C_s"
+#' )
+#'
+#' # Look at model summary for a given fit
+#' # First set of double parentheses selects an individual group value
+#' # Second set selects an element of the sublist
+#' summary(fits[[3]][[1]])
+#'
+#' # Print the parameters
+#' fits[[3]][[2]]
+#'
+#' # Print the graph
+#' fits[[3]][[3]]
+#'
+#' # Compile graphs into a list for plotting
+#' fits_graphs <- compile_data(fits,
+#'   list_element = 3
+#' )
+#'
+#' # Print graphs to pdf
+#' # Uncomment to run
+#' # print_graphs(data = fits_graphs,
+#' #            output_type = "pdf",
+#' #            path = tempdir(),
+#' #            pdf_filename = "mygraphs.pdf")
+#' }
+print_graphs <- function(data,
+                         path,
+                         output_type = "jpeg",
+                         height = 5,
+                         width = 5,
+                         res = 600,
+                         units = "in",
+                         pdf_filename,
+                         ...) {
+  # Is output_type compatible with options?
+  if (!output_type %in% c("pdf", "jpeg")) {
+    stop("Output type not found. Use pdf or jpeg")
+  }
+  if (!missing(path)) {
+    # Print out individual jpeg files
+    if (output_type == "jpeg") {
+      for (i in 1:length(data)) {
+        jpeg(paste(names(data[i])[1], ".jpeg"),
+          height = height, width = width,
+          res = res, units = units, ...
+        )
+        print(data[[i]])
+        dev.off()
+      }
+    }
+    # Print out pdf with all graphs
+    if (output_type == "pdf") {
+      pdf(pdf_filename, ...)
+      old_mfrow = par()$mfrow
+      par(mfrow = c(2, 2))
+      on.exit(par(mfrow = old_mfrow))
+      for (i in 1:length(data)) {
+        plot(data[[i]], main = names(data[i]))
+      }
+      dev.off()
+    }
+  } else {
+    message("Graphs not printed. 'path' argument required.")
+  }
+}

data/R/read_licor.R

@@ -0,0 +1,185 @@
+#' Read a LI-COR file
+#' 
+#' @description
+#' `r lifecycle::badge("deprecated")`
+#' 
+#' We are no longer updating this function. Please use \code{\link{read_licor}} instead.
+#' 
+#' @param x File name
+#'
+#' @return Returns a data.frame from raw LI-COR files. Current support
+#' for LI-COR LI-6800 files only. 
+#' @importFrom utils read.csv
+#'
+#' @md
+#' @export
+read_li6800 = function(x) {
+  
+  lifecycle::deprecate_soft("2.1.3", "read_li6800()", with = "read_licor()")
+  
+  # Read in header information
+  header <- read.csv(
+    file = x, header = TRUE, sep = "\t",
+    skip = grep(
+      pattern = "\\[Data\\]",
+      x = readLines(x),
+      value = FALSE
+    ) + 1,
+    nrows = 1
+  )
+  # Read in data information
+  data <- read.csv(
+    file = x, header = FALSE, sep = "\t",
+    skip = grep(
+      pattern = "\\[Data\\]",
+      x = readLines(x),
+      value = FALSE
+    ) + 3
+  )
+  # Add header to data
+  colnames(data) <- colnames(header)
+  # Return data
+  return(data)
+}
+
+#' Read a LI-COR file
+#' 
+#' @description
+#' `r lifecycle::badge("experimental")`
+#' 
+#' Reads a raw LI-COR LI6800 file, including remarks. This function was
+#' developed using output from Bluestem v.2.0.04 to v.2.1.08. We cannot
+#' guarantee backward compatibility with earlier versions of Bluestem. We will 
+#' try to update code when new versions are released, but there maybe a 
+#' time-lag, so inspect results carefully.
+#' 
+#' @param file Path to a raw LI6800 file
+#' @param bluestem_version Character string of Bluestem software version number. By default, the function will try to pull the version number from file.
+#' @param ... Argument passed to \code{\link[readr]{read_lines}}
+#'
+#' @return Returns a \code{\link[tibble]{tibble}} from raw LI-COR LI6800 files. 
+#'
+#' @export
+read_licor = function(
+    file,
+    bluestem_version = get_bluestem_version(file, n_max = 10L),
+    ...
+) {
+  
+  v1 = "2.0.04"
+  v2 = "2.1.08"
+  checkmate::assert_string(bluestem_version)
+
+  if (numeric_version(bluestem_version) < v1) {
+    warning(glue::glue("It appears you are using data from Bluestem version {bluestem_version}. `read_licor()` function was developed with versions starting at {v1} and has not been tested with earlier versions. Inspect results carefully."))
+  }
+  
+  if (numeric_version(bluestem_version) > v2) {
+    warning(glue::glue("It appears you are using data from Bluestem version {bluestem_version}. `read_licor()` function was developed with versions up to {v2} and has not been tested with more recent versions. Inspect results carefully."))
+  }
+  
+  # Read lines
+  all_lines = readr::read_lines(file, ...)
+  
+  # Extract header information and covert to named list
+  header = all_lines |>
+    extract_licor_header() |>
+    purrr::map(stringr::str_split_1, "\t") |>
+    purrr::map(restructure_licor_header_line) %>%
+    rlang::set_names(sapply(., `[`, 1L)) |>
+    purrr::map(`[`, -1L)
+  
+  # Extract remarks and convert to tibble
+  remarks = extract_licor_remarks(all_lines)
+  
+  df_remarks = remarks |>
+    tibble::as_tibble() |>
+    tidyr::separate(col = "value", into = c("time", "remark"), sep = "\t") 
+  
+  # Extract parameter settings
+  # Most of these are in header, but this will also remove lines from data when 
+  # parameter settings are changed between logging
+  parameter_settings = names(header) %>%
+    magrittr::extract(stringr::str_detect(., "^.*:.*")) |>
+    stringr::str_c(collapse = "|") %>%
+    paste0("^(", ., ")\\t.*") %>%
+    stringr::str_extract(all_lines, .) |>
+    stats::na.omit()
+  
+  # Extract data and convert to a tibble
+  data_block = setdiff(all_lines, c(remarks, parameter_settings))
+  data_start_line = stringr::str_detect(data_block, "\\[Data\\]")
+  var_names = stringr::str_split_1(data_block[which(data_start_line) + 2L],
+                                   pattern = "\t")
+  
+  utils::read.table(
+    text = data_block[(which(data_start_line) + 4L):length(data_block)],
+    sep = "\t"
+  ) |>
+    magrittr::set_colnames(var_names) |>
+    magrittr::set_attr("remarks", df_remarks) |>
+    magrittr::set_attr("header", header)
+    
+}
+
+#' Get Bluestem version from LI6800 file
+#' 
+#' @inheritParams read_licor
+#' @param ... Argument passed to \code{\link[readr]{read_lines}}
+#' @noRd
+get_bluestem_version = function(file, ...) {
+  x1 = readr::read_lines(file, ...)
+  ver_number_string = "[0-9]+.[0-9]+.[0-9]+"
+  ver_string = paste0("Console ver\tBluestem v.", ver_number_string)
+  ver_line = which(stringr::str_detect(x1, ver_string))
+  stringr::str_extract(x1[ver_line], ver_number_string)
+}
+
+#' Extract header table from a LI6800 raw file
+#' @noRd
+extract_licor_header = function(.x) {
+  header_line = "\\[Header\\]"
+  data_line = "\\[Data\\]"
+  first_line = stringr::str_detect(.x, header_line) |>
+    which() |>
+    magrittr::add(1L)
+  last_line = stringr::str_detect(.x, data_line) |>
+    which() |>
+    magrittr::subtract(1L)
+  
+  # Remove remarks
+  header = .x[first_line:last_line]
+  remarks = extract_licor_remarks(header)
+  
+  setdiff(header, remarks)
+}
+
+#' Extract remarks from a LI6800 raw file
+#' @noRd
+extract_licor_remarks = function(.x) {
+  # Remark lines have time stamp, tab, and no more '\t' in remainder of line
+  remark_line = "^[0-2][0-9]:[0-5][0-9]:[0-5][0-9]\t(?!.*(\t))"
+  .x[stringr::str_detect(.x, remark_line)]
+}
+
+#' Restructure LI6800 header rows
+#' @description
+#' Restructures header rows in raw LI6800 files as needed. Currently, it only alters the row with Stability Definition
+#' @param header_line A character vector from one row in the header after splitting by tabs.
+#' @noRd
+restructure_licor_header_line = function(header_line) {
+  checkmate::assert_character(header_line)
+  
+  # Restructure Stability Definition line
+  ret = if (
+    stringr::str_detect(header_line[1], "^[0-2][0-9]:[0-5][0-9]:[0-5][0-9]$") &
+    stringr::str_detect(header_line[2], "^Stability Definition:$")
+  ) {
+    header_line[2:length(header_line)]
+  } else{
+    header_line
+  }
+  
+  ret
+  
+}

data/R/simulate_error.R

@@ -0,0 +1,200 @@
+#' Simulate gas exchange data with measurement error
+#' 
+#' @description 
+#' 
+#' `r lifecycle::badge("experimental")`
+#' 
+#' @param ph_out A data frame of output from `photo()` or `photosynthesis()` 
+#' with units.
+#' @param chamber_pars A data frame with a single row of chamber parameters. 
+#' See Note below for table of required parameters. 
+#' @param n Integer. Number of replicated simulations per row of `ph_out`.
+#' @param use_tealeaves Flag. The **tealeaves** package uses a slightly 
+#' different equation to calculate the saturating water content of air as a 
+#' function temperature and pressure than LI-COR. If FALSE, the function uses 
+#' LI-COR's equation in the LI6800 manual. If TRUE, it uses the **tealeaves** 
+#' function for internal consistency. The function attempts to guess whether 
+#' `ph_out` was run with **tealeaves**, but this can be manually overridden by 
+#' providing a value for the argument.
+#' 
+#' @return A data frame with `n * nrow(ph_out)` rows. It contains all the 
+#' original output in `ph_out` as well as a column `.rep` indicating replicate 
+#' number from 1 to `n`. Other new columns are assumed or measured chamber 
+#' parameters and 'measured' values estimated from synthetic data with 
+#' measurement error:
+#' 
+#' | column name | assumed or derived? | description |
+#' |-------------|---------------------|-------------|
+#' | `flow`      | assumed             | chamber flow rate |
+#' | `leaf_area` | assumed             | leaf area in chamber |
+#' | `sigma_CO2_r` | assumed           | standard deviation of measurement error in CO2_r |
+#' | `sigma_CO2_s` | assumed           | standard deviation of measurement error in CO2_s |
+#' | `sigma_H2O_r` | assumed           | standard deviation of measurement error in H2O_r |
+#' | `sigma_H2O_s` | assumed           | standard deviation of measurement error in H2O_s |
+#' | `c_0`       | derived             | CO\eqn{_2} concentration before entering chamber \[\eqn{\mu}mol / mol\] |
+#' | `w_i`       | derived             | Water vapor concentration within leaf \[mmol / mol\] |
+#' | `w_a`       | derived             | Water vapor concentration in chamber \[mmol / mol\] |
+#' | `w_0`       | derived             | Water vapor concentration before entering chamber \[mmol / mol\] |
+#' | `g_tw`      | derived             | Leaf conductance to water vapor \[mol/m\eqn{^2}/s\] |
+#' | `E_area`    | derived             | Evaporation rate per area \[mmol/m\eqn{^2}/s\] |
+#' | `E`         | derived             | Total evaporation rate \[mmol/s\] |
+#' | `CO2_r`       | derived             | CO\eqn{_2} concentration before entering chamber with measurement error \[\eqn{\mu}mol / mol\] |
+#' | `CO2_s`       | derived             | CO\eqn{_2} concentration in chamber with measurement error \[\eqn{\mu}mol / mol\] |
+#' | `H2O_s`       | derived           | Water vapor concentration in chamber with measurement error \[mmol / mol\] |
+#' | `H2O_r`       | derived           | Water vapor concentration before entering chamber with measurement error \[mmol / mol\] |
+#' | `E_meas`        | derived             | Total evaporation rate (measured) \[mmol/s\] |
+#' | `E_area_meas`   | derived             | Evaporation rate per area (measured) \[mmol/m\eqn{^2}/s\] |
+#' | `g_tw_meas`     | derived             | Leaf conductance to water vapor (measured) \[mol/m\eqn{^2}/s\] |
+#' | `g_sc_meas`     | derived             | Stomatal conductance to CO\eqn{_2} (measured) \[mol/m\eqn{^2}/s\] |
+#' | `g_tc_meas`     | derived             | Leaf conductance to CO\eqn{_2} (measured) \[mol/m\eqn{^2}/s\] |
+#' | `A_meas`        | derived             | Net photosynthetic CO\eqn{_2} assimilation (measured) \[\eqn{\mu}mol/m\eqn{^2}/s\] |
+#' | `C_i`           | derived             | Intercellular CO\eqn{_2} concentration (measured) \[\eqn{\mu}mol/mol\] |
+#' 
+#' @note 
+#' The required parameters for the `chamber_pars` argument are:
+#' 
+#' * `flow` \[\eqn{\mu}mol / s\]: chamber flow rate
+#' * `leaf_area` \[cm ^ 2\]: leaf area in chamber
+#' * `sigma_CO2_s` \[\eqn{\mu}mol / mol\]: standard deviation of sample \[CO\eqn{_2}\] measurement error
+#' * `sigma_CO2_r` \[\eqn{\mu}mol / mol\]: standard deviation of reference [CO\eqn{_2}\]
+#' * `sigma_H2O_s` \[mmol / mol\]: standard deviation of sample \[H\eqn{_2}O\] measurement error
+#' * `sigma_H2O_r` \[mmol / mol\]: standard deviation of sample \[H\eqn{_2}O\] measurement error
+#' 
+#' Units for `flow` and `leaf_area` should be provided; units are implied for sigma's but not necessary to specify because `rnorm()` drop units.
+#' 
+#' To evaluate the accuracy and precision of parameter estimation methods, it 
+#' may be useful to simulate data with realistic measurement error. This 
+#' function takes output from from `photo()` or `photosynthesis()` models, adds 
+#' measurement error in CO\eqn{_2} and H\eqn{_2}O concentrations, and calculates
+#' parameter estimates with synthetic data. Currently, the function assumes a 
+#' simplified 1-dimensional CO\eqn{_2} and H\eqn{_2}O conductance model: zero 
+#' cuticular conductance, infinite boundary layer conductance, and infinite 
+#' airspace conductance. Other assumptions include:
+#' 
+#' * chamber flow rate, leaf area, leaf temperature, and air pressure are known
+#' without error
+#' * measurement error is normally distributed mean 0 and standard deviation 
+#' specified in `chamber_pars`
+#' 
+#' This function was designed with the LI-COR LI6800 instrument in mind, but in
+#' principle applies to any open path gas exchange system.
+#' 
+#' @examples 
+#' library(photosynthesis)
+#' 
+#' # Use photosynthesis() to simulate 'real' values
+#' # `replace = ...` sets parameters to meet assumptions of `simulate_error()`
+#' lp = make_leafpar(replace = list(
+#'   g_sc = set_units(0.1, mol/m^2/s),
+#'   g_uc = set_units(0, mol/m^2/s),
+#'   k_mc = set_units(0, 1),
+#'   k_sc = set_units(0, 1),
+#'   k_uc = set_units(0, 1)
+#'   ),
+#'   use_tealeaves = FALSE)
+#'    
+#'  ep = make_enviropar(replace = list(
+#'    wind = set_units(Inf, m/s)
+#'  ), use_tealeaves = FALSE) 
+#'  bp = make_bakepar()
+#'  cs = make_constants(use_tealeaves = FALSE)
+#'  
+#'  chamber_pars = data.frame(
+#'    flow = set_units(600, umol / s),
+#'    leaf_area = set_units(6, cm ^ 2),
+#'    sigma_CO2_s = 0.1,
+#'    sigma_CO2_r = 0.1,
+#'    sigma_H2O_s = 0.1,
+#'    sigma_H2O_r = 0.1
+#'  )
+#'    
+#' ph = photosynthesis(lp, ep, bp, cs, use_tealeaves = FALSE, quiet = TRUE) |>
+#'   simulate_error(chamber_pars, n = 1L)
+#'   
+#' @md
+#' @export
+simulate_error = function(
+    ph_out,
+    chamber_pars,
+    n = 1L,
+    use_tealeaves = ("T_air" %in% colnames(ph_out))
+  ) {
+  
+  lifecycle::signal_stage("experimental", what = "simulate_error()")
+  
+  # Check
+  checkmate::assert_data_frame(ph_out, any.missing = FALSE, min.rows = 1L)
+  c("A", "C_i", "g_sc", "P", "T_leaf") %in% colnames(ph_out) |>
+    all() |>
+    checkmate::assert_true()
+  checkmate::assert_data_frame(chamber_pars, any.missing = FALSE, nrows = 1L)
+  c("flow", "leaf_area", "sigma_CO2_r", "sigma_CO2_s", "sigma_H2O_r", "sigma_H2O_s") |>
+    magrittr::is_in(colnames(chamber_pars)) |>
+    all() |>
+    checkmate::assert_true()
+  checkmate::assert_number(chamber_pars$flow, lower = 0, finite = TRUE)
+  checkmate::assert_number(chamber_pars$leaf_area, lower = 0, finite = TRUE)
+  checkmate::assert_number(chamber_pars$sigma_CO2_r, lower = 0, finite = TRUE)
+  checkmate::assert_number(chamber_pars$sigma_CO2_s, lower = 0, finite = TRUE)
+  checkmate::assert_number(chamber_pars$sigma_H2O_r, lower = 0, finite = TRUE)
+  checkmate::assert_number(chamber_pars$sigma_H2O_s, lower = 0, finite = TRUE)
+  checkmate::assert_int(n)
+  checkmate::assert_flag(use_tealeaves)
+  
+  # Replicate ph_out n times and add chamber parameters
+  tidyr::crossing(
+    .rep = seq_len(n),
+    ph_out,
+    chamber_pars
+  ) %>%
+    dplyr::mutate(
+      
+      # Assume water vapour concentration is saturated within leaf, w_i [mmol/mol]
+      w_i = if (use_tealeaves) {
+    # Use tealeaves version for internal consistency
+    .get_ps(T_leaf, P, FALSE) |>
+      magrittr::divide_by(P) |>
+      set_units(mmol/mol)
+  } else {
+    # LI-6800 equation
+    T_leaf = set_units(T_leaf, degreeC) |>
+      drop_units()
+    P = set_units(P, kPa) |>
+      drop_units()
+    w_i = set_units((1000 * 0.61365 * exp(17.502 * T_leaf / (240.97 + T_leaf)) / P), mmol / mol)
+  },
+  # Calculate [H2O] in chamber based on RH
+  w_a = set_units(.data$RH * w_i, mmol / mol),
+  # Assume all g_tw = g_sw (i.e. g_uw = 0; g_bw = Inf
+  g_tw = .data$g_sc * 1.6,
+  E_area = set_units(.data$g_tw * (w_i - .data$w_a), mmol / m^2 / s),
+  E = .data$E_area * .data$leaf_area, # [mmol / s]
+  w_0 = set_units(.data$w_a - .data$E * (set_units(1) - .data$w_a) / .data$flow,
+                  mmol / mol),
+  c_0 = set_units(.data$leaf_area * .data$A / .data$flow + 
+                    .data$C_air * (set_units(1) - .data$w_0) / 
+                    (set_units(1) - .data$w_a), umol / mol),
+  
+  # Simulate measurements with error
+  H2O_s = .data$w_a + set_units(rnorm(nrow(.), 0, .data$sigma_H2O_s), 
+                                mmol / mol),
+  H2O_r = .data$w_0 + set_units(rnorm(nrow(.), 0, .data$sigma_H2O_r), 
+                                mmol / mol),
+  CO2_s = .data$C_air + set_units(rnorm(nrow(.), 0, .data$sigma_CO2_s), 
+                                  umol / mol),
+  CO2_r = .data$c_0 + set_units(rnorm(nrow(.), 0, .data$sigma_CO2_r), 
+                                umol / mol),
+  
+  # Derived estimates with error
+  E_meas = set_units(.data$flow * (.data$H2O_s - .data$H2O_r) / 
+                       (set_units(1) - .data$H2O_s), mmol/s),
+  E_area_meas = set_units(.data$E_meas / .data$leaf_area, mmol / m^2 / s),
+  g_tw_meas = .data$E_area_meas * (set_units(1) - (.data$w_i + .data$H2O_s) / 2) / (.data$w_i - .data$H2O_s),
+  g_sc_meas = .data$g_tw_meas / 1.6, # this is only valid if cuticular conductance is 0 and boundary layer conductance is Inf
+  g_tc_meas = .data$g_sc_meas, # valid above assumption is true and g_mc is Inf
+  A_meas = set_units(.data$flow * (.data$CO2_r - .data$CO2_s * ((set_units(1) - .data$H2O_r) / (set_units(1) - .data$H2O_s))) / .data$leaf_area, umol / m^2 / s),
+  C_i_meas = set_units(((.data$g_tc_meas - .data$E_area_meas / 2) * .data$CO2_s - .data$A_meas) / (.data$g_tc_meas + .data$E_area_meas / 2), umol/mol)
+  
+    ) 
+  
+}

data/R/t_functions.R

@@ -0,0 +1,134 @@
+#' Temperature response functions
+#'
+#' @param T_leaf Leaf temperature in K
+#'
+#' @param a Constant to minimize residuals (Heskel et al. 2016)
+#' @param b Linear coefficient to minimize residuals (Heskel et al. 2016)
+#' @param c Quadratic coefficient to minimize residuals (Heskel et al. 2016)
+#'
+#' @param T2 Leaf temperature term (Kruse et al. 2008)
+#' @param dEa Temperature-dependent change in Ea in K^2 (Kruse et al. 2008)
+#' @param Ea_ref Activation energy in J mol-1 (Kruse et al. 2008)
+#' @param Par_ref Parameter at reference temperature of 25 Celsius (Kruse et
+#' al. 2008)
+#'
+#' @param dS Entropy parameter in J mol-1 (Medlyn et al. 2002)
+#' @param Ea Activation energy in J mol-1 (Medlyn et al. 2002)
+#' @param Hd Deactivation energy in J mol-1 (Medlyn et al. 2002)
+#' @param Topt Optimum temperature of the process in K (Medlyn et al.
+#' 2002)
+#'
+#' @param dH Change in enthalpy of the reaction at 25 C in J mol-1 (Hobbs et
+#' al. 2013)
+#' @param dCp Change in heat capacity of the enzyme between the
+#' enzyme-substrate #' and enzyme-transition states in J mol-1 K-1 (Hobbs et
+#' al. 2013)
+#' @param dG Change in Gibbs free energy of the reaction at 25 C in J mol-1
+#' (Hobbs et al. 2013)
+#'
+#' @return t_response_arrhenius calculates the rate of a process based on an
+#' Arrhenius-type curve
+#'
+#' t_response_arrhenius_kruse fits a peaked Arrhenius response according to
+#' Kruse et al. 2008.
+#'
+#' t_response_arrhenius_medlyn is a peaked Arrhenius response as found in
+#' Medlyn et al. 2002.
+#'
+#' t_response_arrhenius_topt is a peaked Arrhenius temperature response
+#' function.
+#'
+#' t_response_calc_dS calculates dS from the fitted Topt model.
+#'
+#' t_response_calc_topt calculates Topt for a process from Arrhenius
+#' parameters.
+#'
+#' t_response_heskel is a quadratic temperature response according to
+#' Heskel et al. 2016.
+#'
+#' t_response_mmrt is a macromolecular rate theory temperature response
+#' according to Hobbs et al. 2013.
+#'
+#' @references
+#'
+#' Arrhenius S. 1915. Quantitative laws in biological chemistry. Bell.
+#'
+#' Heskel et al. 2016. Convergence in the temperature response of leaf
+#' respiration across biomes and plant functional types. PNAS 113:3832-3837
+#'
+#' Hobbs et al. 2013. Change in heat capacity for enzyme catalysis
+#' determines temperature dependence of enzyme catalyzed rates. ACS Chemical
+#' Biology 8:2388-2393
+#'
+#' Kruse J, Adams MA. 2008. Three parameters comprehensively describe
+#' the temperature response of respiratory oxygen reduction. Plant
+#' Cell Environ 31:954-967
+#'
+#' Medlyn BE, Dreyer E, Ellsworth D, Forstreuter M, Harley PC,
+#' Kirschbaum MUF, Le Roux X, Montpied P, Strassemeyer J, Walcroft A,
+#' Wang K, Loutstau D. 2002. Temperature response of parameters of a
+#' biochemically based model of photosynthesis. II. A review of
+#' experimental data. Plant Cell Environ 25:1167-1179
+#'
+#' @rdname t_functions
+#' @export
+t_response_arrhenius <- function(T_leaf, Ea) {
+  exp(Ea * ((T_leaf) - 298.15) /
+    (298.15 * 8.314 * (T_leaf)))
+}
+
+#' @rdname t_functions
+#' @export
+t_response_arrhenius_kruse <- function(dEa, Ea_ref, Par_ref, T2) {
+  log(Par_ref) + (Ea_ref / 8.314) * T2 + dEa * T2^2
+}
+
+#' @rdname t_functions
+#' @export
+t_response_arrhenius_medlyn <- function(T_leaf, Ea, Hd, dS) {
+  exp(Ea * ((T_leaf) - 298.15) /
+    (298.15 * 8.314 * (T_leaf))) *
+    (1 + exp((298.15 * dS - Hd) / (298.15 * 8.314))) /
+    (1 + exp(((T_leaf) * dS - Hd) / ((T_leaf) * 8.314)))
+}
+
+#' @rdname t_functions
+#' @export
+t_response_arrhenius_topt <- function(T_leaf, Ea, Hd, Topt) {
+  Hd * exp(Ea * ((T_leaf) - (Topt)) /
+    ((T_leaf) * (Topt) * 8.314)) /
+    (Hd - Ea * (1 - exp(Hd * ((T_leaf) - (Topt)) /
+      ((T_leaf) * (Topt) * 8.314))))
+}
+
+#' @rdname t_functions
+#' @export
+t_response_calc_dS <- function(Ea,
+                               Hd,
+                               Topt) {
+  Hd / Topt + 8.314 * log(Ea / (Hd - Ea))
+}
+
+#' @rdname t_functions
+#' @export
+t_response_calc_topt <- function(Hd, dS, Ea) {
+  Hd / (dS - 8.314 * log(Ea / (Hd - Ea)))
+}
+
+#' @rdname t_functions
+#' @export
+t_response_heskel <- function(T_leaf, a, b, c) {
+  a + b * (T_leaf - 273.15) + c * (T_leaf - 273.15)^2
+}
+
+#' @rdname t_functions
+#' @export
+t_response_mmrt <- function(dCp,
+                            dG,
+                            dH,
+                            T_leaf) {
+  (log(1.380649e-23 * (298.15) / 6.62607e-34)) -
+    dG / (8.314 * 298.15) +
+    (1 / 298.15 + dH / (8.314 * 298.15^2)) * ((T_leaf) - 298.15) +
+    (dCp / (2 * 8.314 * 298.15^2)) * ((T_leaf) - 298.15)^2
+}

data/R/utils.R

@@ -0,0 +1,93 @@
+#' Convert pressure from PPM to Pascals
+#'
+#' @param ppm Pressure value in umol/mol of class `units`
+#' @param P Atmospheric pressure value in kPa of class `units`
+#'
+#' @return Value in Pa of class `units`
+#'
+#' @details
+#'
+#' \deqn{\mathrm{Press}(kPa) = \mathrm{Press}(ppm) P(kPa)}{Press(kPa) = Press(ppm) P(kPa)}
+#' \deqn{\mathrm{Press}(Pa) = 1000 \mathrm{Press}(kPa)}{Press(Pa) = 1000 Press(kPa)}
+#'
+#' @examples
+#'
+#' ppm = set_units(400, "umol/mol")
+#' P = set_units(101.325, "kPa")
+#' ppm2pa(ppm, P)
+#' @export
+#'
+
+ppm2pa = function(ppm, P) {
+  set_units(ppm * P, Pa)
+}
+
+#' Convert number to scientific notation in LaTeX or R documentation
+#' 
+#' @param x vector of numbers to convert
+#' @param .threshold integer threshold for order of magnitude to use scientific notation
+#' @param .digits integer number of significant digits
+#' @param .format character indicating whether to format output for LaTeX "latex" or R documentation "r"
+#' 
+#' @noRd
+scientize = function(x, .threshold = -1L, .digits = 2L, .format = "r") {
+  
+  purrr::map_chr(x, function(.x, .threshold, .digits, .format) {
+    
+    if (is.na(.x)) {
+      return(NA) 
+    } else {
+      oom = log10(abs(.x))
+      if (oom < .threshold) {
+        x1 = .x |>
+          magrittr::multiply_by(10 ^ -floor(oom)) |>
+          round(.digits)
+        
+        x2 = sprintf(glue::glue("%.{.digits}f"), x1) |>
+          stringr::str_c("\\times 10^{", floor(oom), "}") 
+        
+        if (.format == "r") {
+          x2 = glue::glue("\\eqn{<x2>}", .open = "<", .close = ">")
+        }
+        
+        return(x2)
+      } else {
+        x1 = .x |>
+          signif(.digits + 1L) |>
+          as.character()
+        return(x1)
+      }
+    }
+  }, .threshold = .threshold, .digits = .digits, .format = .format)
+  
+}
+
+#' Make table for R documentation on photosynthesis parameters
+#' 
+#' @param ... arguments passed to dplyr::filter()
+#' 
+#' @noRd
+make_photo_parameter_table = function(...) {
+  
+  photosynthesis::photo_parameters |>
+    dplyr::filter(...) |>
+    dplyr::mutate(
+      Symbol = glue::glue("\\eqn{<symbol>}", .open = "<", .close = ">"),
+      R = glue::glue("\\code{<R>}", .open = "<", .close = ">"),
+      Units = stringr::str_replace_all(units, "([A-Za-z]+)\\^([0-9]+)",
+                                       "\\1\\\\eqn{^\\2}"),
+      Default = scientize(.data$default, .threshold = -2L, .format = "r")
+    ) |>
+    dplyr::select(.data$Symbol, .data$R, Description = .data$description, 
+                  .data$Units, .data$Default) |>
+    knitr::kable()
+  
+}
+
+#' Round a numeric value to nearest element in set of possible values
+#' @noRd
+round_to_nearest = function(x, values) {
+  sapply(x, function(y, values) {
+    values[which.min(abs(y - values))]
+  }, values = values)
+}

data/README.Rmd

@@ -0,0 +1,103 @@
+---
+output: github_document
+pagetitle: README
+---
+
+<!-- README.md is generated from README.Rmd. Please edit that file -->
+
+```{r echo=FALSE}
+knitr::opts_chunk$set(
+  warning = FALSE,
+  message = FALSE,
+  collapse = TRUE,
+  comment = "#>",
+  fig.path = "man/figures/README-",
+  out.width = "100%"
+)
+```
+# photosynthesis <img src="man/figures/logo.png" align="right" height="200" width="200"/>
+
+<!-- badges: start -->
+[![CRAN status](https://www.r-pkg.org/badges/version/photosynthesis)](https://cran.r-project.org/package=photosynthesis)
+[![](https://cranlogs.r-pkg.org/badges/photosynthesis)](https://cran.r-project.org/package=photosynthesis)
+[![R-CMD-check](https://github.com/cdmuir/photosynthesis/actions/workflows/R-CMD-check.yaml/badge.svg)](https://github.com/cdmuir/photosynthesis/actions/workflows/R-CMD-check.yaml)
+<!-- badges: end -->
+
+## Model C3 Photosynthesis
+
+## Description
+
+**photosynthesis** is an R package with modeling tools for C3 photosynthesis, as well as analytical tools for curve-fitting plant ecophysiology responses. It uses the R package [**units**](https://CRAN.R-project.org/package=units) to ensure that parameters are properly specified and transformed before calculations. 
+
+## Get **photosynthesis**
+
+From CRAN
+
+```r
+install.packages("photosynthesis")
+```
+
+or from GitHub
+
+```r
+install.packages("remotes")
+remotes::install_github("cdmuir/photosynthesis")
+```
+
+And load `photosynthesis`
+
+```r
+library("photosynthesis")
+```
+
+## Vignettes
+
+See the following vignettes for examples of what **photosynthesis** can do:
+
+* [Introduction to the photosynthesis package][photosynthesis-introduction]
+* [Modeling C3 Photosynthesis: recommendations for common scenarios][modeling-recommendations]
+* [Fitting light response curves][light-response]
+* [Fitting CO2 response curves][co2-response]
+* [Fitting temperature response curves][temperature-response]
+* [Fitting stomatal conductance models][stomatal-conductance]
+* [Fitting light respiration][light-respiration]
+* [Fitting mesophyll conductance][mesophyll-conductance]
+* [Fitting pressure-volume curves][pressure-volume]
+* [Fitting hydraulic vulnerability curves][hydraulic-vulnerability]
+* [Sensitivity Analysis][sensitivity-analysis]
+
+[photosynthesis-introduction]: https://cdmuir.github.io/photosynthesis/articles/photosynthesis-introduction.html
+[modeling-recommendations]: https://cdmuir.github.io/photosynthesis/articles/modeling-recommendations.html
+[light-response]: https://cdmuir.github.io/photosynthesis/articles/light-response.html
+[co2-response]: https://cdmuir.github.io/photosynthesis/articles/co2-response.html
+[temperature-response]: https://cdmuir.github.io/photosynthesis/articles/temperature-response.html
+[stomatal-conductance]: https://cdmuir.github.io/photosynthesis/articles/stomatal-conductance.html
+[light-respiration]: https://cdmuir.github.io/photosynthesis/articles/light-respiration.html
+[mesophyll-conductance]: https://cdmuir.github.io/photosynthesis/articles/mesophyll-conductance.html
+[pressure-volume]: https://cdmuir.github.io/photosynthesis/articles/pressure-volume.html
+[hydraulic-vulnerability]: https://cdmuir.github.io/photosynthesis/articles/hydraulic-vulnerability.html
+[sensitivity-analysis]: https://cdmuir.github.io/photosynthesis/articles/sensitivity-analysis.html
+
+## Contributors
+
+* [Joseph Stinziano](https://github.com/jstinzi)
+* [Chris Muir](https://github.com/cdmuir)
+* Cassaundra Roback
+* Demi Sargent
+* Bridget Murphy
+* Patrick Hudson
+
+## Comments and contributions
+
+We welcome comments, criticisms, and especially contributions!
+GitHub issues are the preferred way to report bugs, ask questions, or request new features.
+You can submit issues here:
+
+https://github.com/cdmuir/photosynthesis/issues
+
+## Meta
+
+* Please [report any issues or bugs](https://github.com/cdmuir/photosynthesis/issues).
+* License: MIT
+* Get citation information for **photosynthesis** in R doing `citation(package = 'photosynthesis')`
+* Please note that this project is released with a [Contributor Code of Conduct](https://github.com/cdmuir/photosynthesis/blob/master/CONDUCT.md). By participating in this project you agree to abide by its terms.

data/_pkgdown.yml

@@ -0,0 +1,4 @@
+url: https://github.com/cdmuir/photosynthesis
+
+template:
+  bootstrap: 5

data/cran-comments.md

@@ -0,0 +1,25 @@
+## Summary of new changes
+
+* Fixed broken URL in NEWS.md
+* Added `photoinhibition()` to light response models. This allows users to estimate photoinhibition at high light.
+
+## Test environments
+* local R installation, R 4.4.2
+* ubuntu 22.04.5 (on Github actions), R 4.4.2
+* rhub (version 2): 
+  - Ubuntu 22.04.5, R-devel, gcc
+  - Microsoft Windows Server 2022 10.0.20348, R-devel
+  - macOS 13.7.1, R-release, clang
+
+## R CMD check results
+
+❯ checking installed package size ... NOTE
+    installed size is  7.4Mb
+    sub-directories of 1Mb or more:
+      doc   6.2Mb
+
+## rhub results
+Tested using `rhub` version 2. All checks passed successfully on the above platforms.
+
+## Downstream dependencies
+No known issues with downstream dependencies.

data/data-raw/li6800_example.R

@@ -0,0 +1,8 @@
+## code to prepare `li6800_example` dataset goes here
+
+usethis::use_data(li6800_example, overwrite = TRUE)
+
+file.copy(
+  "/Users/cdmuir/Library/CloudStorage/[email protected]/Shared drives/muir-lab/adaptive-amphistomy/raw-data/licor/2023-04-23-0804_logdata",
+  "inst/extdata/li6800_example"
+)

data/data-raw/photo-2d-parameters.R

@@ -0,0 +1,7 @@
+## code to prepare `photo-2d-parameters` data set goes here
+
+# Import shared parameters from photo_parameters
+photo_parameters = readr::read_csv("inst/extdata/photo-parameters.csv")
+photo_2d_parameters = readr::read_csv("inst/extdata/photo-2d-parameters.csv")
+
+usethis::use_data(photo_parameters, overwrite = TRUE)

data/data-raw/photo-parameters.R

@@ -0,0 +1,4 @@
+## code to prepare `photo-parameters` data set goes here
+photo_parameters = readr::read_csv("inst/extdata/photo-parameters.csv")
+            
+usethis::use_data(photo_parameters, overwrite = TRUE)