bhpm.cluster.BB.hier2 {bhpm} | R Documentation |

Implementation of a Two-Level Hierarchical for grouped data and clusters with Point-Mass.

```
bhpm.cluster.BB.hier2(cluster.data, sim_type = "SLICE", burnin = 20000,
iter = 60000, nchains = 5, theta_algorithm = "MH",
global.sim.params = data.frame(type = c("MH", "MH", "MH", "MH",
"SLICE", "SLICE", "SLICE"),
param = c("sigma_MH_alpha", "sigma_MH_beta", "sigma_MH_gamma",
"sigma_MH_theta", "w_alpha", "w_beta", "w_gamma"),
value = c(3, 3, 0.2, 0.5, 1, 1, 1), control = c(0, 0, 0, 0, 6, 6, 6),
stringsAsFactors = FALSE),
sim.params = NULL,
monitor = data.frame(variable = c("theta", "gamma", "mu.gamma",
"mu.theta", "sigma2.theta", "sigma2.gamma", "pi"),
monitor = c(1, 1, 1, 1, 1, 1, 1), stringsAsFactors = FALSE),
initial_values = NULL, level = 1,
hyper_params = list(mu.gamma.0 = 0, tau2.gamma.0 = 10, mu.theta.0 = 0,
tau2.theta.0 = 10, alpha.gamma = 3, beta.gamma = 1, alpha.theta = 3,
beta.theta = 1, alpha.pi = 1.1, beta.pi = 1.1),
global.pm.weight = 0.5,
pm.weights = NULL,
adapt_phase=1, memory_model = "HIGH")
```

`cluster.data` |
A file or data frame containing the cluster data. It must contain the columns |

`burnin` |
The burnin period for the monte-carlo simulation. These are discarded from the returned samples. |

`iter` |
The total number of iterations for which the monte-carlo simulation is run. This includes the burnin period.
The total number of samples returned is |

`nchains` |
The number of independent chains to run. |

`theta_algorithm` |
MCMC algorithm used to sample the theta variables. "MH" is the only currently supported stable algorithm. |

`sim_type` |
The type of MCMC method to use for simulating from non-standard distributions apart from theta. Allowed values are |

`monitor` |
A dataframe indicating which sets of variables to monitor. |

`global.sim.params` |
A data frame containing the parameters for the simuation type |

`sim.params` |
A dataframe containing simulation parameters which override the global simulation parameters ( The function |

`initial_values` |
The initial values for starting the chains. If NULL (the default) is passed the function generates the initial values for the chains. initial_values is a list with the following format: list(gamma, theta, mu.gamma, mu.theta, sigma2.gamma, sigma2.theta, pi, mu.gamma.0, mu.theta.0, tau2.gamma.0, tau2.theta.0, alpha.pi, beta.pi) The function |

`level` |
Allowed valus are 0, 1. Respectively these indicate independent clusters, common means across the clusters. |

`hyper_params` |
The hyperparameters for the model. |

`global.pm.weight` |
A global weighting for the proposal distribution used to sample theta. |

`pm.weights` |
Override global.pm.weight for specific outcomes. |

`adapt_phase` |
Unused parameter. |

`memory_model` |
Allowed values are "HIGH" and "LOW". "HIGH" means use as much memory as possible. "LOW" means use the minimum amount of memory. |

The model is fitted by a Gibbs sampler.

The output from the simulation including all the sampled values is as follows:

list(id, theta_alg, sim_type, chains, nClusters, Clusters, Trt.Grps, nOutcome.Grp, maxOutcome.Grps, maxOutcomes, nOutcome, Outcome, Outcome.Grp, burnin, iter, monitor, mu.gamma, mu.theta, sigma2.gamma, sigma2.theta, pi, gamma, theta, gamma_acc, theta_acc)

where

*id* - a string identifying the verions of the function

*theta_alg* - an string identifying the algorithm used to smaple theta

*sim_type* - an string identifying the samlping method used for non-standard distributions, either *"MH"* or *"SLICE"*

*chains* - the number of chains for which the simulation was run

*nClusters* - the number of clusters in the simulation

*Clusters* - an array. The clusters.

*nOutcome.Grp* - the number of outcome groupings.

*maxOutcome.Grps* - the maximum number of outcome groupings in a cluster.

*maxOutcomes* - the maximum number of outcomes in an outcome grouping.

*nOutcome* - an array. The number of outcomes in each outcome grouping.

*Outcome* - an array of dimension *nOutcome.Grp*, *maxOutcomes*. The outcomes.

*Outcome.Grp* - an array. The outcome groupings.

*burnin* - burnin used for the simulation.

*iter* - the total number of iterations in the simulation.

*monitor* - the variables being monitored. A dataframe.

*mu.gamma* - array of generated samples.

*mu.theta* - array of generated samples.

*sigma2.gamma* - array of generated samples.

*sigma2.theta* - array of generated samples.

*pi* - array of generated samples.

*gamma* - array of generated samples.

*theta* - array of generated samples.

*gamma_acc* - the acceptance rate for the gamma samples if a Metropolis-Hastings method is used.

*theta_acc* - the acceptance rate for the theta samples.

The function performs the simulation and returns the raw output. No checks for convergence are performed.

R. Carragher

```
data(bhpm.cluster.data1)
raw = bhpm.cluster.BB.hier2(bhpm.cluster.data1, level = 1, burnin = 100, iter = 200)
data(bhpm.cluster.data1)
raw = bhpm.cluster.BB.hier2(bhpm.cluster.data1, level = 1)
```

[Package *bhpm* version 1.7 Index]