SoilR (version 1.2.107)

Model: Constructor for class Model

Description

This function creates an object of class Model, The arguments can be given in different form as long as they can be converted to the necessary internal building blocks. (See the links)

Usage

Model(
  t,
  A,
  ivList,
  inputFluxes,
  solverfunc = deSolve.lsoda.wrapper,
  pass = FALSE
)

Value

An object of class Model that can be queried by many methods to be found there.

Arguments

t

A vector containing the points in time where the solution is sought.

A

something that can be converted by GeneralDecompOp to any of the available subclasses of DecompOp.

ivList

A numeric vector containing the initial amount of carbon for the n pools. The length of this vector is equal to the number of pools. This is checked by an internal function.

inputFluxes

something that can be converted by InFluxes to any of the available subclasses of InFluxes.

solverfunc

The function used to actually solve the ODE system. The default is deSolve.lsoda.wrapper but you can also provide your own function that the same interface.

pass

Forces the constructor to create the model even if it does not pass internal sanity checks

Details

This function Model wraps the internal constructor of class Model. The internal constructor requires the argument A to be of class DecompOp and argument inputFluxes to be of class InFluxes. Before calling the internal constructor Model calls GeneralDecompOp on its argument A and InFluxes on its argument inputFluxes to convert them into the required classes. Both are generic functions. Follow the links to see for which kind of inputs conversion methods are available. The attempted conversion allows great flexibility with respect to arguments and independence from the actual implementation. However if your code uses the wrong argument the error will most likely occur in the delegate functions. If this happens inspect the error message (or use traceback()) to see which function was called and try to call the constructor of the desired subclass explicitly with your arguments. The subclasses are linked in the class documentation DecompOp or InFluxes respectively.

Note also that this function checks its arguments quite elaborately and tries to detect accidental unreasonable combinations, especially concerning two kinds of errors.

1. unintended extrapolation of time series data

2. violations of mass balance by the DecompOp argument.

SoilR has a lot of unit tests which are installed with the package and are sometimes instructive as examples. To see example scenarios for parameter check look at: system.file('tests','runit.correctness_of_Model.R',package='SoilR')

See Also

This function is called by many of the predefinedModels.
Package functions called in the examples:
example.2DInFluxes.Args,
example.2DGeneralDecompOpArgs,

Examples

# vim:set ff=unix expandtab ts=2 sw=2:
test.all.possible.Model.arguments <- function(){
  # This example shows different kinds of arguments to the function Model.
  # The model objects we will build will share some common features.
  #  - two pools 
  #  - initial values 

  iv<-  c(5,6)
  times <- seq(1,10,by=0.1)

  # The other parameters A and inputFluxes will be different
  # The function Model will transform these arguments 
  # into objects of the classes required by the internal constructor.
  # This leads to a number of possible argument types. 
  # We demonstrate some of the possibilities here.
  # Let us first look at the choeices for argument 'A'.
  
  #) 
  possibleAs  <- example.2DGeneralDecompOpArgs()
  
  # Since "Model" will call "InFluxes" on its "inputFluxes" 
  # argument there are again different choices
  # we have included a function in SoilR that produces 2D examples
  
  possibleInfluxes <- example.2DInFluxes.Args()
 print(possibleInfluxes$I.vec)
  # We can build a lot of  models from the possible combinations
  # for instance   
  #m1 <- Model(
  #        t=times,
  #        A=matrix(nrow=2,byrow=TRUE,c(-0.1,0,0,-0.2)),
  #        ivList=iv,
  #        inputFluxes=possibleInfluxes$I.vec) 
  ## We now produce all combinations of As and InputFluxes
  combinations <- listProduct(possibleAs,possibleInfluxes)
  print(length(combinations))
  # and a Model for each
  models <- lapply(
              combinations,
              function(combi){
                #Model(t=times,A=combi$A,ivList=iv,inputFluxes=combi$I)
                Model(t=times,A=combi[[1]],ivList=iv,inputFluxes=combi[[2]])
              }
            )
  ## lets check that we can compute something# 
  lapply(models,getC)
}