INTRODUCTION           package:sensitivity           R Documentation

_P_a_c_k_a_g_e '_s_e_n_s_i_t_i_v_i_t_y': _S_e_n_s_i_t_i_v_i_t_y _A_n_a_l_y_s_i_s

_D_e_s_c_r_i_p_t_i_o_n:

     The 'sensitivity' package implements sensitivity analysis methods:
     linear and monotonic sensitivity analysis (SRC, PCC, SRRC, PRCC),
     the screening method of Morris, and non-linear global sensitivity
     analysis (the Sobol indices, the FAST method).

     The functions of this package generate the design of experiments
     (depending on the method of analysis) and compute the sensitivity
     indices based on the model inputs and outputs. All sensitivity
     indices can be estimated with the bootstrap technique which allows
     to estimate the bias, and basic bootstrap confidence intervals.
     Text and graphical outputs display the results of the analysis.

_D_e_t_a_i_l_s:

     The approach applied when performing a sensitivity analysis (SA)
     is as follows:

     _s_t_e_p _1 The model is defined: it is a function that returns the
          (real) ouput values (called responses), corresponding to a
          sample of (real) input parameters (called factors).

     _s_t_e_p _2 A sensitivity analysis method is chosen. Parameters of this
          method must be in accordance with objectives and technical
          constraints (like computational time).

     _s_t_e_p _3 A design of experiments (DOE) corresponding to the SA
          method is generated.

     _s_t_e_p _4 The model is evaluated on the DOE values.

     _s_t_e_p _5 The sensitivity indices are computed, based on input and
          output values.

     _s_t_e_p _6 Post-treatments...

     The 'sensitivity' package allows to follow this methodology:

     (step 1) The model can be internal or external to R. If internal,
     it can be a function that takes an unique 'matrix' or 'data.frame'
     parameter and returns a 'numeric' vector. It can also be a
     predictor, i.e. an object wich can be called with the 'predict'
     method. One should note that all the responses must be computed by
     a single call to the model function (then, the model can be
     vectorized).
      If the model is external it does not have to be interfaced with
     R: the user won't have to give a model to the function. Then, it
     will stop just after generating the DOE. The responses have to be
     computed by the user, whithin R or not. Calculations will start
     again when the user gives the corresponding responses (via the
     'tell' function). 

     The four next steps depend upon the type of the model:

     For internal models:
      (step 2-5) 'sa <- method(model, parameters...)'

     For external models:
      (step 2-3) 'sa <- method(model = NULL, parameters...)'
      (step 4) external to R (or not), and the result is loaded by the
     user in the y variable
      (step 5) 'tell(sa, y)'

     'method' should be the name of a SA function, such as 'srcpcc',
     'morris', 'sobol', or 'fast'. These function create the object
     'sa' of class '"srcpcc"', '"morris"', '"sobol"', or '"fast"'. For
     further information on these function, see the corresponding
     documentation.

     Finally, for displaying the results of the analysis:
      (step 6) 'print(sa); plot(sa)'

_R_e_f_e_r_e_n_c_e_s:

     Saltelli, A., Chan, K. and Scott, E. M., 2000, _Sensitivity
     analysis_. Wiley, 33-45.

_S_e_e _A_l_s_o:

     'srcpcc' 'morris' 'sobol'   'fast' 'tell' 'testmodels'

