If `my_stanfit`

is a stanfit object (the result of fitting a model with **rstan**), then to launch the ShinyStan app simply use

```
library(shinystan)
my_sso <- launch_shinystan(my_stanfit)
```

and ShinyStan will launch. Here `my_sso`

is the name you want to use for the shinystan object that will be returned. If you simply run

`launch_shinystan(my_stanfit)`

then ShinyStan will launch but no shinystan object will be saved upon quitting the app.

If you have an `mcmc.list`

object called `my_mcmc`

then you can use the `as.shinystan`

function to convert `my_mcmc`

into a shinystan object that can then be used with `launch_shinystan`

:

`my_sso <- launch_shinystan(as.shinystan(my_mcmc, model_name = "my_model"))`

If, for example, the first 100 iterations in each chain in `my_mcmc`

are warmup iterations, you should add the `warmup`

argument when you call `as.shinystan`

:

`my_sso <- launch_shinystan(as.shinystan(my_mcmc, model_name = "my_model", warmup = 100))`

However, you should only use the `warmup`

argument if the warmup iterations have been saved and included in `my_mcmc`

.

To convert a 3-D array to a shinystan object make sure that the three dimensions of the array correspond to the *number of iterations* **x** *number of chains* **x** *number of parameters*. You can then `as.shinystan`

exactly how it’s used in the examples for `mcmc.list`

objects above (but you don’t need to convert your array to an `mcmc.list`

).

If you have separate chains that are each a matrix (with iterations as rows and parameters as columns) you can combine them in a list to pass to `as.shinystan`

```
# Generate some fake data
chain1 <- cbind(beta1 = rnorm(100), beta2 = rnorm(100), sigma = rexp(100))
chain2 <- cbind(beta1 = rnorm(100), beta2 = rnorm(100), sigma = rexp(100))
chain_list <- list(chain1, chain2)
my_sso <- launch_shinystan(as.shinystan(X = list(chain1, chain2), model_name = "my_model"))
```

You can add a new parameter/quantity as a function of one or two existing parameters to your shinystan object by using the `generate_quantity`

function. For example, assume `sso`

is a shinystan object and two of the parameters are `alpha`

and `beta`

. We could add a parameter `gamma`

that is the inverse logit of `beta`

using the code

```
inv_logit <- function(x) 1/(1 + exp(-x))
sso <- generate_quantity(sso, fun = inv_logit, param1 = "beta", new_name = "gamma")
```

Here, `fun`

is the function we want to use, `param1`

is the name of the parameter to apply the function to, and `new_name`

is the name to give the new parameter.

Adding a parameter as a function of two parameters just requires specifying the `param2`

argument and providing a function of two variables. For example, we can add a parameter `delta`

to `sso`

that is the squared difference of `alpha`

and `beta`

like this

```
sso <- generate_quantity(sso, fun = function(x,y) (x-y)^2,
param1 = "alpha", param2 = "beta", new_name = "delta")
```

For models fit using **rstan** the model code will automatically be stored in the `model_code`

slot of your shinystan object. When ShinyStan is open you can view your model code in the *Model Code* tab.

If you did not use **rstan** fit your model then you can add your model code by using the `model_code()`

function. For example, you may have used Bugs or JAGS or some other software and want to add the following code

```
for (i in 1:length(Y)) {
Y[i] ~ dpois(lambda[i])
log(lambda[i]) <- inprod(X[i,], theta[])
}
for (j in 1:J) {
theta[j] ~ dt(0.0, 1.0, 1.0)
}
}
```

to your shinystan object. To add that code you can simply include it as the `code`

argument to the `model_code`

function

```
my_code <- "
model {
for (i in 1:length(Y)) {
Y[i] ~ dpois(lambda[i])
log(lambda[i]) <- inprod(X[i,], theta[])
}
for (j in 1:J) {
theta[j] ~ dt(0.0, 1.0, 1.0)
}
}
"
# Add the code to a shinystan object sso
sso <- model_code(sso, code = my_code)
```

On the home page ShinyStan will display the model name associated with the shinystan object being used. This name can be set by adding the `model_name`

argument to `as.shinystan`

when creating a shinystan object. For an existing shinystan object you can use the `model_name`

function like this:

`sso <- model_name(sso, "new_model_name")`

where `"new_model_name"`

is the new name you want to give your model.