

######################### 
# Preliminary Simulations 
#########################  

library( doSNOW )
library( itertools )
library( doParallel )
library( foreach )

# How many cores are there
#ncl <- detectCores( ) 
# How many cores are there
#ncl <- detectCores( )

# Set up parallel simulations on 10 cores
cl <- makeCluster( 20 , outfile="MicroMiss_Setting_4_bran_large_r1.txt", setup_strategy = "sequential")
registerDoSNOW(cl)



################################################################################################################



# How many cores are there
#ncl <- detectCores( )

# Set up parallel simulations on 10 cores
# cl <- parallel::makeCluster(30)
# doParallel::registerDoParallel(cl)
# 
#cl <- makeCluster(detectCores())
#registerDoParallel( cores = 20)
#registerDoSEQ()

ans <- foreach( iter = 1:15, # 50 is the number of simulations
                .combine=rbind, .packages = c( "Rcpp", "RcppArmadillo",  "MCMCpack", "dirmult","mvtnorm", "MicroMiss", "ZIDM"), .noexport = c("MicroMiss", "ZIDM")
) %dopar%
  {
    #catcher <- numeric()
    # x <- c( "Rcpp", "RcppArmadillo",  "MCMCpack","mvtnorm", "ZIDM")
    # lapply(x, require, character.only = TRUE)
    #for(iter in 1:30){
    
    # Load the software
    #setwd("/Users/mkoslovsky/Desktop/HSSjointFiles")
    
    set.seed( iter )
    setwd("/data/koslovsk/MissMicroRevision1/Simulations") 
    library( Rcpp )
    library( RcppArmadillo ) 
    
# Generate data
    active_cov <- 3
    data <- simulate_MicroMiss( missclass_prob = c( 0.60, 0.20, 0.20 ), N = 50, T. = 50, C. = 50, P_eta = 10, P_gamma = 50, total = 10000, active_cov = active_cov)
    
    
# Set up parameters
iterations <- 5000
thin <- 5
samples <- floor(iterations/thin)
Z <- array( 0, dim = c( data$N, data$T., samples ) ) 
Zsum <- rowSums( data$Y )
alpha_it <- array( 0, dim = c( data$N, data$T., samples ) ) 
mu_i <- matrix( 0, data$N, samples ) # rep( 0, N )
zeta_it <- array( 0, dim = c( data$N, data$T., samples ) )
omega_eta <- array( 0, dim = c( data$N, data$T., samples ) )
beta_eta <- array( 0, dim = c( data$T., data$P_eta, samples ) )
beta_gamma <- array( 0, dim = c( data$T., data$P_gamma, samples ) )
zeta_eta <- array( 0, dim = c( data$T., data$P_eta, samples ) )
zeta_eta[,1,] <- 1
zeta_gamma <- array( 0, dim = c( data$T., data$P_gamma, samples ) )
zeta_gamma[,1,] <- 1

a_tc <- array( 0, dim = c( data$T., data$C., samples ) )
u_t <- rep( 1, data$T. )

# Set up priors 
nu <- matrix( 1, nrow = data$T., ncol = data$C. )
diag( nu ) <- 100 
mu_beta_eta_prior <- matrix( 0, data$T., data$P_eta )
mu_beta_gamma_prior <- matrix( 0, data$T., data$P_gamma )
sigma2_beta_eta <- 1
sigma2_beta_gamma <- 1

# Initialize
Z[ , , 1 ] <- data$Y
alpha_it[ , , 1 ] <- data$Y
for( n in 1:nrow( data$Y ) ){
  sum_Z <- sum( data$Y[ n, ] )
  mu_i[ n, 1 ] <- rgamma( 1, sum_Z, sum_Z );
}
zeta_it[ , , 1 ] <- 1
omega_eta[ , , 1 ] <- 1
a_tc[ , , 1 ] <- 1 

a_zeta_gamma <- 1
a_zeta_eta <- 1
b_zeta_gamma <- 9
b_zeta_eta <- 1

# Beta gamma true
beta_gamma_true <- data$beta_gamma_true
X_gamma <- data$X_gamma
effect <- function(beta, cov, j, p){
  adding <- rep( 0, length( cov ) )
  adding[ p ] <- 1
  exp( beta[ j, p ] )*sum( exp( beta%*%cov ) ) / sum( exp( beta%*%(cov + adding ) ) )
}

true_gamma_unit <- array( 0, dim = c( data$N, data$T., data$P_gamma - 1 ) )
for( p in 2:data$P_gamma ){
  for( i in 1:data$N ){
    for( t in 1:data$T. ){
      true_gamma_unit[ i, t, p - 1 ] <- effect( beta_gamma_true, X_gamma[ i, ], t, p ) 
    }
  }
}


ptm_MicroMissBVS <- proc.time() 
output_MMBVS <- MicroMissBVS( iterations, thin, data$N, data$T., data$C., data$P_eta, data$P_gamma, data$Y, Z, Zsum, alpha_it, zeta_it, beta_eta, zeta_eta, data$X_eta, 
                     omega_eta, beta_gamma, zeta_gamma, data$X_gamma, mu_i, a_tc, u_t, nu, mu_beta_eta_prior, mu_beta_gamma_prior, sigma2_beta_eta, sigma2_beta_gamma, a_zeta_gamma,  b_zeta_gamma, a_zeta_eta, b_zeta_eta  )
time_MicroMissBVS <- proc.time() - ptm_MicroMissBVS

names( output_MMBVS ) <- c( "Z", "alpha_t", "zeta", "beta_eta", "omega_eta", "a_tc", "beta_gamma", "mu", "zeta_eta", "zeta_gamma" )

save( output_MMBVS , file = paste( "/data/koslovsk/MissMicroRevision1/setting_4_bran_large_outputMMBVS_r1_iter_", iter, ".rda", sep = "" ) )

# Selection 
MPPI_MMBVS_zeta_gamma <- apply( output_MMBVS$zeta_gamma [ ,, (floor(samples)/2 + 1):(floor(samples)) ], c(1,2), mean )
MPPI_MMBVS_zeta_eta <- apply( output_MMBVS$zeta_eta[ ,, (floor(samples)/2 + 1):(floor(samples)) ], c(1,2), mean )

# at-risk coeff
post_beta_eta_MMBVS <- apply( output_MMBVS$beta_eta[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), mean )  
post_beta_eta_MMBVS_upper <- apply( output_MMBVS$beta_eta[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
post_beta_eta_MMBVS_lower <- apply( output_MMBVS$beta_eta[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.025 ) } ) 

abs_beta_eta_MMBVS_sig <- c( abs( post_beta_eta_MMBVS[,-1] - data$beta_eta_true[,-1] )[ data$beta_eta_true[,-1] != 0 ] )  # mean( abs_beta_eta_MMBVS_sig )

abs_beta_eta_MMBVS_non <- c( abs( post_beta_eta_MMBVS[,-1] - data$beta_eta_true[,-1])[ data$beta_eta_true[,-1] == 0 ] )  # mean( abs_beta_eta_MMBVS_sig )

cov_beta_eta_MMBVS <- post_beta_eta_MMBVS_upper[,-1] > data$beta_eta_true[,-1] & post_beta_eta_MMBVS_lower[,-1] < data$beta_eta_true[,-1]

cov_beta_eta_MMBVS_sig <- cov_beta_eta_MMBVS[ data$beta_eta_true[,-1] != 0 ]

cov_beta_eta_MMBVS_non <-  cov_beta_eta_MMBVS[ data$beta_eta_true[,-1] == 0 ]


# mean( cov_beta_eta_MMBVS_sig ) mean( cov_beta_eta_MMBVS_non )
# mean( cov_beta_eta_ZIDM  ) mean( cov_beta_eta_ZIDM_non  )

# abundance est
post_beta_gamma_MMBVS <- apply( output_MMBVS$beta_gamma[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), mean )  
post_beta_gamma_MMBVS_upper <- apply( output_MMBVS$beta_gamma[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
post_beta_gamma_MMBVS_lower <- apply( output_MMBVS$beta_gamma[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.025 ) } ) 

abs_beta_gamma_MMBVS_sig <- c( abs( post_beta_gamma_MMBVS[,-1] - data$beta_gamma_true[,-1] )[ data$beta_gamma_true[,-1] != 0 ] )  # mean( abs_beta_gamma_MMBVS_sig )

abs_beta_gamma_MMBVS_non <- c( abs( post_beta_gamma_MMBVS[,-1] - data$beta_gamma_true[,-1] )[ data$beta_gamma_true[,-1] == 0 ] )  # mean( abs_beta_gamma_MMBVS_non )

cov_beta_gamma_MMBVS <- post_beta_gamma_MMBVS_upper[,-1] > data$beta_gamma_true[,-1] & post_beta_gamma_MMBVS_lower[,-1] < data$beta_gamma_true[,-1]

cov_beta_gamma_MMBVS_sig <- cov_beta_gamma_MMBVS[ data$beta_gamma_true[,-1] != 0 ] # mean( cov_beta_gamma_MMBVS_sig )

cov_beta_gamma_MMBVS_non <-  cov_beta_gamma_MMBVS[ data$beta_gamma_true[,-1] == 0 ] # mean( cov_beta_gamma_MMBVS_non )

# classification
a_norm_t <- apply( output_MMBVS$a_tc[ , , (floor(samples)/2 + 1):(floor(samples)) ], c(1,3), sum ) 
theta <- output_MMBVS$a_tc[ , , (floor(samples)/2 + 1):(floor(samples)) ] 
for (i in 1:length((floor(samples)/2 + 1):(floor(samples))) ){
  theta[,,i] <- theta[,,i]/a_norm_t[,i]
}
post_theta <- apply( theta , c(1,2), mean )  
post_theta_upper <- apply( theta , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
post_theta_lower <- apply( theta , c(1,2), function( x ){ quantile( x , 0.025 ) } )  

#View(cbind(diag(post_theta),diag(observe_prob/rowSums(observe_prob))))
abs_theta_MMBVS <- abs( c( post_theta - data$classifications ) ) 
cov_theta_MMBVS <- c( post_theta_upper > data$classifications & post_theta_lower < data$classifications )


# relative abundance
alpha_norm_MMBVS <- apply( output_MMBVS$alpha_t[ , , (floor(samples)/2 + 1):(floor(samples)) ], c(1,3), sum ) 
psi_MMBVS <- output_MMBVS$alpha_t[ , , (floor(samples)/2 + 1):(floor(samples)) ] 
for (i in 1:length((floor(samples)/2 + 1):(floor(samples))) ){
  psi_MMBVS[,,i] <- psi_MMBVS[,,i]/alpha_norm_MMBVS[,i]
}
post_psi_MMBVS <- apply( psi_MMBVS , c(1,2), mean )  
post_psi_MMBVS_upper <- apply( psi_MMBVS , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
post_psi_MMBVS_lower <- apply( psi_MMBVS , c(1,2), function( x ){ quantile( x , 0.025 ) } )  

abs_psi_MMBVS <- c( abs( post_psi_MMBVS - data$true_prob ) )  

cov_psi_MMBVS <- c( post_psi_MMBVS_upper > data$true_prob & post_psi_MMBVS_lower < data$true_prob )


# Beta gamma MMBVS 
gamma_unit_mean <- array( 0, dim = c( data$N, dim(output_MMBVS$beta_gamma)[1], dim(output_MMBVS$beta_gamma)[2] - 1 ) )
gamma_unit_upper <- array( 0, dim = c( data$N, dim(output_MMBVS$beta_gamma)[1], dim(output_MMBVS$beta_gamma)[2] - 1 ) )
gamma_unit_lower <- array( 0, dim = c( data$N, dim(output_MMBVS$beta_gamma)[1], dim(output_MMBVS$beta_gamma)[2] - 1 ) )

for( p in 2:data$P_gamma ){
  MCMC_gamma_unit <- array( 0, dim = c( data$N, dim(output_MMBVS$beta_gamma)[1], samples ) ) 
  MCMC_gamma_unit <- effects_all( output_MMBVS$beta_gamma, X_gamma, data$T., samples, p ) 
  gamma_unit_mean[,,p - 1] <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), mean )  
  gamma_unit_upper[,,p - 1] <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
  gamma_unit_lower[,,p - 1] <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.025 ) } ) 
}

ave_gamma_MMBVS <- mean( abs( gamma_unit_mean - true_gamma_unit ) )
cov_gamma_MMBVS <- mean( c( gamma_unit_upper > true_gamma_unit & gamma_unit_lower < true_gamma_unit ))
 
remove(output_MMBVS)


ptm_MicroMiss <- proc.time() 
output <- MicroMiss( iterations, thin, data$N, data$T., data$C., data$P_eta, data$P_gamma, data$Y, Z, Zsum, alpha_it, zeta_it, beta_eta, data$X_eta, 
                     omega_eta, beta_gamma, data$X_gamma, mu_i, a_tc, u_t, nu, mu_beta_eta_prior, mu_beta_gamma_prior, sigma2_beta_eta, sigma2_beta_gamma )
time_MicroMiss <- proc.time() - ptm_MicroMiss
  
names( output ) <- c( "Z", "alpha_t", "zeta", "beta_eta", "omega_eta", "a_tc", "beta_gamma", "mu")

save( output , file = paste( "/data/koslovsk/MissMicroRevision1/setting_4_bran_large_outputMicroMiss_r1_iter_", iter, ".rda", sep = "" ) )

# at-risk coeff
post_beta_eta_MicroMiss <- apply( output$beta_eta[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), mean )  
post_beta_eta_MicroMiss_upper <- apply( output$beta_eta[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
post_beta_eta_MicroMiss_lower <- apply( output$beta_eta[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.025 ) } ) 

abs_beta_eta_MicroMiss_sig <- c( abs( post_beta_eta_MicroMiss[,-1] - data$beta_eta_true[,-1] )[ data$beta_eta_true[,-1] != 0 ] ) # mean( abs_beta_eta_MicroMiss_sig )
 
abs_beta_eta_MicroMiss_non <- c( abs( post_beta_eta_MicroMiss[,-1] - data$beta_eta_true[,-1] )[ data$beta_eta_true[,-1] == 0 ] )  # mean( abs_beta_eta_MicroMiss_sig )
 
cov_beta_eta_MicroMiss <- post_beta_eta_MicroMiss_upper[,-1] > data$beta_eta_true[,-1] & post_beta_eta_MicroMiss_lower[,-1] < data$beta_eta_true[,-1]
 
cov_beta_eta_MicroMiss_sig <- cov_beta_eta_MicroMiss[ data$beta_eta_true[,-1] != 0 ]
 
cov_beta_eta_MicroMiss_non <-  cov_beta_eta_MicroMiss[ data$beta_eta_true[,-1] == 0 ]
 
 
# mean( cov_beta_eta_MicroMiss_sig ) mean( cov_beta_eta_MicroMiss_non )
# mean( cov_beta_eta_ZIDM  ) mean( cov_beta_eta_ZIDM_non  )

# abundance est
post_beta_gamma_MicroMiss <- apply( output$beta_gamma[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), mean )  
post_beta_gamma_MicroMiss_upper <- apply( output$beta_gamma[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
post_beta_gamma_MicroMiss_lower <- apply( output$beta_gamma[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.025 ) } ) 
 
abs_beta_gamma_MicroMiss_sig <- c( abs( post_beta_gamma_MicroMiss[,-1] - data$beta_gamma_true[,-1] )[ data$beta_gamma_true[,-1] != 0 ] )  # mean( abs_beta_gamma_MicroMiss_sig )

abs_beta_gamma_MicroMiss_non <- c( abs( post_beta_gamma_MicroMiss[,-1] - data$beta_gamma_true[,-1] )[ data$beta_gamma_true[,-1] == 0 ] )  # mean( abs_beta_gamma_MicroMiss_non )
 
cov_beta_gamma_MicroMiss <- post_beta_gamma_MicroMiss_upper[,-1] > data$beta_gamma_true[,-1] & post_beta_gamma_MicroMiss_lower[,-1] < data$beta_gamma_true[,-1]
 
cov_beta_gamma_MicroMiss_sig <- cov_beta_gamma_MicroMiss[ data$beta_gamma_true[,-1] != 0 ] # mean( cov_beta_gamma_MicroMiss_sig )
 
cov_beta_gamma_MicroMiss_non <-  cov_beta_gamma_MicroMiss[ data$beta_gamma_true[,-1] == 0 ] # mean( cov_beta_gamma_MicroMiss_non )
 
# classification
a_norm_t <- apply( output$a_tc[ , , (floor(samples)/2 + 1):(floor(samples)) ], c(1,3), sum ) 
theta <- output$a_tc[ , , (floor(samples)/2 + 1):(floor(samples)) ] 
for (i in 1:length((floor(samples)/2 + 1):(floor(samples))) ){
  theta[,,i] <- theta[,,i]/a_norm_t[,i]
}
post_theta <- apply( theta , c(1,2), mean )  
post_theta_upper <- apply( theta , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
post_theta_lower <- apply( theta , c(1,2), function( x ){ quantile( x , 0.025 ) } )  

#View(cbind(diag(post_theta),diag(observe_prob/rowSums(observe_prob))))
abs_theta_MicroMiss <- abs( c( post_theta - data$classifications ) ) 
cov_theta_MicroMiss <- c( post_theta_upper > data$classifications & post_theta_lower < data$classifications )


# relative abundance
alpha_norm_MicroMiss <- apply( output$alpha_t[ , , (floor(samples)/2 + 1):(floor(samples)) ], c(1,3), sum ) 
psi_MicroMiss <- output$alpha_t[ , , (floor(samples)/2 + 1):(floor(samples)) ] 
for (i in 1:length((floor(samples)/2 + 1):(floor(samples))) ){
  psi_MicroMiss[,,i] <- psi_MicroMiss[,,i]/alpha_norm_MicroMiss[,i]
}
post_psi_MicroMiss <- apply( psi_MicroMiss , c(1,2), mean )  
post_psi_MicroMiss_upper <- apply( psi_MicroMiss , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
post_psi_MicroMiss_lower <- apply( psi_MicroMiss , c(1,2), function( x ){ quantile( x , 0.025 ) } )  

abs_psi_MicroMiss <- c( abs( post_psi_MicroMiss - data$true_prob ) )  
 
cov_psi_MicroMiss <- c( post_psi_MicroMiss_upper > data$true_prob & post_psi_MicroMiss_lower < data$true_prob )

# Beta gamma MicroMISS 
gamma_unit_mean <- array( 0, dim = c( data$N, dim(output$beta_gamma)[1], dim(output$beta_gamma)[2] - 1 ) )
gamma_unit_upper <- array( 0, dim = c( data$N, dim(output$beta_gamma)[1], dim(output$beta_gamma)[2] - 1 ) )
gamma_unit_lower <- array( 0, dim = c( data$N, dim(output$beta_gamma)[1], dim(output$beta_gamma)[2] - 1 ) )

for( p in 2:data$P_gamma ){
  MCMC_gamma_unit <- array( 0, dim = c( data$N, dim(output$beta_gamma)[1], samples ) ) 
  MCMC_gamma_unit <- effects_all(output$beta_gamma, X_gamma, data$T., samples, p ) 
  gamma_unit_mean[,,p - 1] <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), mean )  
  gamma_unit_upper[,,p - 1] <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
  gamma_unit_lower[,,p - 1] <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.025 ) } ) 
}

ave_gamma_MicroMiss <- mean( abs( gamma_unit_mean - true_gamma_unit ) )
cov_gamma_MicroMiss <- mean( c( gamma_unit_upper > true_gamma_unit & gamma_unit_lower < true_gamma_unit ))


remove(output)

ptm_ZIDM <- proc.time() 
#output_ZIDM <- ZIDM( iterations, thin, data$N, data$T., data$P_eta, data$P_gamma, data$Y, Zsum, alpha_it, zeta_it, beta_eta, data$X_eta, 
#                     omega_eta, beta_gamma, data$X_gamma, mu_i, mu_beta_eta_prior, mu_beta_gamma_prior, sigma2_beta_eta, sigma2_beta_gamma )
output_ZIDM <- ZIDM::ZIDMbvs_R( data$Y, data$X_gamma[,-1], data$X_eta[,-1], iterations, thin, sigma2_beta_gamma, sigma2_beta_eta, a_zeta_gamma, b_zeta_gamma, a_zeta_eta, b_zeta_eta )

time_ZIDM <- proc.time() - ptm_ZIDM

# names( output_ZIDM ) <- c( "alpha_t", "zeta", "beta_eta", "omega_eta", "beta_gamma")
names( output_ZIDM ) <- c( "zeta_gamma", "beta_gamma",  "zeta", "beta_eta", "zeta_eta","omega_eta", "eta_accept",   "alpha_t" )

save( output_ZIDM , file = paste( "/data/koslovsk/MissMicroRevision1/setting_4_bran_large_outputZIDM_r1_iter_", iter, ".rda", sep = "" ) )

# Selection 
MPPI_ZIDM_zeta_gamma <- apply( output_ZIDM$zeta_gamma [ ,, (floor(samples)/2 + 1):(floor(samples)) ], c(1,2), mean )
MPPI_ZIDM_zeta_eta <- apply( output_ZIDM$zeta_eta[ ,, (floor(samples)/2 + 1):(floor(samples)) ], c(1,2), mean )   

# at-risk coeff
post_beta_eta_ZIDM <- apply( output_ZIDM$beta_eta[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), mean )  
post_beta_eta_ZIDM_upper <- apply( output_ZIDM$beta_eta[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
post_beta_eta_ZIDM_lower <- apply( output_ZIDM$beta_eta[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.025 ) } ) 

abs_beta_eta_ZIDM_sig <- c( abs( post_beta_eta_ZIDM[,-1] - data$beta_eta_true[,-1] )[ data$beta_eta_true[,-1] != 0 ] )   # mean( abs_beta_eta_ZIDM_sig )

abs_beta_eta_ZIDM_non <- c( abs( post_beta_eta_ZIDM[,-1] - data$beta_eta_true[,-1] )[ data$beta_eta_true[,-1] == 0 ] )   # mean( abs_beta_eta_ZIDM_sig )

cov_beta_eta_ZIDM <- post_beta_eta_ZIDM_upper[,-1] > data$beta_eta_true[,-1] & post_beta_eta_ZIDM_lower[,-1] < data$beta_eta_true[,-1]

cov_beta_eta_ZIDM_sig <- cov_beta_eta_ZIDM[ data$beta_eta_true[,-1] != 0 ]

cov_beta_eta_ZIDM_non <-  cov_beta_eta_ZIDM[ data$beta_eta_true[,-1] == 0 ]
 
# abundance est 
post_beta_gamma_ZIDM <- apply( output_ZIDM$beta_gamma[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), mean )  
post_beta_gamma_ZIDM_upper <- apply( output_ZIDM$beta_gamma[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
post_beta_gamma_ZIDM_lower <- apply( output_ZIDM$beta_gamma[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.025 ) } ) 

abs_beta_gamma_ZIDM_sig <- c( abs( post_beta_gamma_ZIDM[,-1] - data$beta_gamma_true[,-1] )[ data$beta_gamma_true[,-1] != 0 ] )  # mean( abs_beta_gamma_ZIDM_sig )

abs_beta_gamma_ZIDM_non <- c( abs( post_beta_gamma_ZIDM[,-1] - data$beta_gamma_true[,-1] )[ data$beta_gamma_true[,-1] == 0 ] ) # mean( abs_beta_gamma_ZIDM_non )

cov_beta_gamma_ZIDM <- post_beta_gamma_ZIDM_upper[,-1] > data$beta_gamma_true[,-1] & post_beta_gamma_ZIDM_lower[,-1] < data$beta_gamma_true[,-1]

cov_beta_gamma_ZIDM_sig <- cov_beta_gamma_ZIDM[ data$beta_gamma_true[,-1] != 0 ] # mean( cov_beta_gamma_ZIDM_sig )

cov_beta_gamma_ZIDM_non <-  cov_beta_gamma_ZIDM[ data$beta_gamma_true[,-1] == 0 ] # mean( cov_beta_gamma_ZIDM_non )
 
# relative abundance
alpha_norm_ZIDM <- apply( output_ZIDM$alpha_t[ , , (floor(samples)/2 + 1):(floor(samples)) ], c(1,3), sum ) 
psi_ZIDM <- output_ZIDM$alpha_t[ , , (floor(samples)/2 + 1):(floor(samples)) ] 
for (i in 1:length((floor(samples)/2 + 1):(floor(samples))) ){
  psi_ZIDM[,,i] <- psi_ZIDM[,,i]/alpha_norm_ZIDM[,i]
}
post_psi_ZIDM <- apply( psi_ZIDM , c(1,2), mean )   
post_psi_ZIDM_upper <- apply( psi_ZIDM , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
post_psi_ZIDM_lower <- apply( psi_ZIDM , c(1,2), function( x ){ quantile( x , 0.025 ) } )  

abs_psi_ZIDM <- c( abs( post_psi_ZIDM - data$true_prob ) ) 

cov_psi_ZIDM <- c( post_psi_ZIDM_upper > data$true_prob & post_psi_ZIDM_lower < data$true_prob )

# Beta gamma ZIDM
gamma_unit_mean <- array( 0, dim = c( data$N, dim(output_ZIDM$beta_gamma)[1], dim(output_ZIDM$beta_gamma)[2] - 1 ) )
gamma_unit_upper <- array( 0, dim = c( data$N, dim(output_ZIDM$beta_gamma)[1], dim(output_ZIDM$beta_gamma)[2] - 1 ) )
gamma_unit_lower <- array( 0, dim = c( data$N, dim(output_ZIDM$beta_gamma)[1], dim(output_ZIDM$beta_gamma)[2] - 1 ) )

for( p in 2:data$P_gamma ){
  MCMC_gamma_unit <- array( 0, dim = c( data$N, dim(output_ZIDM$beta_gamma)[1], samples ) ) 
  MCMC_gamma_unit <- effects_all(output_ZIDM$beta_gamma, X_gamma, data$T., samples, p ) 
  gamma_unit_mean[,,p - 1] <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), mean )  
  gamma_unit_upper[,,p - 1] <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
  gamma_unit_lower[,,p - 1] <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.025 ) } ) 
}
 
ave_gamma_ZIDM <- mean( abs( gamma_unit_mean - true_gamma_unit ) )
cov_gamma_ZIDM <- mean( c( gamma_unit_upper > true_gamma_unit & gamma_unit_lower < true_gamma_unit ))

remove(output_ZIDM)

ptm_DM <- proc.time() 
output_DM <- ZIDM::DMbvs_R(data$Y, data$X_gamma[,-1], iterations, thin, sigma2_beta_gamma, a_zeta_gamma, b_zeta_gamma )
# output_DM <- DM( iterations, thin, data$N, data$T., data$P_gamma, data$Y, Zsum, alpha_it, beta_gamma, data$X_gamma, mu_i, mu_beta_gamma_prior, sigma2_beta_gamma )
time_DM <- proc.time() - ptm_DM

#names( output_DM ) <- c( "alpha_t", "beta_gamma")
names( output_DM ) <- c( "zeta_gamma", "beta_gamma", "zeta", "alpha_t")

save( output_DM , file = paste( "/data/koslovsk/MissMicroRevision1/setting_4_bran_large_outputDM_r1_iter_", iter, ".rda", sep = "" ) )

# Selection 
MPPI_DM_zeta_gamma <- apply( output_DM$zeta_gamma [ ,, (floor(samples)/2 + 1):(floor(samples)) ], c(1,2), mean )
 
# abundance est 
post_beta_gamma_DM <- apply( output_DM$beta_gamma[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), mean )  
post_beta_gamma_DM_upper <- apply( output_DM$beta_gamma[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
post_beta_gamma_DM_lower <- apply( output_DM$beta_gamma[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.025 ) } ) 

abs_beta_gamma_DM_sig <- c( abs( post_beta_gamma_DM[,-1] - data$beta_gamma_true[,-1] )[ data$beta_gamma_true[,-1] != 0 ] ) # mean( abs_beta_gamma_ZIDM_sig )

abs_beta_gamma_DM_non <- c( abs( post_beta_gamma_DM[,-1] - data$beta_gamma_true[,-1] )[ data$beta_gamma_true[,-1] == 0 ] ) # mean( abs_beta_gamma_ZIDM_non )

cov_beta_gamma_DM <- post_beta_gamma_DM_upper[,-1] > data$beta_gamma_true[,-1] & post_beta_gamma_DM_lower[,-1] < data$beta_gamma_true[,-1]

cov_beta_gamma_DM_sig <- cov_beta_gamma_DM[ data$beta_gamma_true[,-1] != 0 ] # mean( cov_beta_gamma_ZIDM_sig )

cov_beta_gamma_DM_non <-  cov_beta_gamma_DM[ data$beta_gamma_true[,-1] == 0 ] # mean( cov_beta_gamma_ZIDM_non )

# relative abundance
alpha_norm_DM <- apply( output_DM$alpha_t[ , , (floor(samples)/2 + 1):(floor(samples)) ], c(1,3), sum ) 
psi_DM <- output_DM$alpha_t[ , , (floor(samples)/2 + 1):(floor(samples)) ] 
for (i in 1:length((floor(samples)/2 + 1):(floor(samples))) ){
  psi_DM[,,i] <- psi_DM[,,i]/alpha_norm_DM[,i]
}
post_psi_DM <- apply( psi_DM , c(1,2), mean )   
post_psi_DM_upper <- apply( psi_DM , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
post_psi_DM_lower <- apply( psi_DM , c(1,2), function( x ){ quantile( x , 0.025 ) } )  

abs_psi_DM <- c( abs( post_psi_DM - data$true_prob ) ) 

cov_psi_DM <- c( post_psi_DM_upper > data$true_prob & post_psi_ZIDM_lower < data$true_prob )

# Beta gamma DM
gamma_unit_mean <- array( 0, dim = c( data$N, dim(output_DM$beta_gamma)[1], dim(output_DM$beta_gamma)[2] - 1 ) )
gamma_unit_upper <- array( 0, dim = c( data$N, dim(output_DM$beta_gamma)[1], dim(output_DM$beta_gamma)[2] - 1 ) )
gamma_unit_lower <- array( 0, dim = c( data$N, dim(output_DM$beta_gamma)[1], dim(output_DM$beta_gamma)[2] - 1 ) )

for( p in 2:data$P_gamma ){
  MCMC_gamma_unit <- array( 0, dim = c( data$N, dim(output_DM$beta_gamma)[1], samples ) ) 
  MCMC_gamma_unit <- effects_all(output_DM$beta_gamma, X_gamma, data$T., samples, p ) 
  gamma_unit_mean[,,p - 1] <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), mean )  
  gamma_unit_upper[,,p - 1] <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
  gamma_unit_lower[,,p - 1] <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.025 ) } ) 
}

ave_gamma_DM <- mean( abs( gamma_unit_mean - true_gamma_unit ) )
cov_gamma_DM <- mean( c( gamma_unit_upper > true_gamma_unit & gamma_unit_lower < true_gamma_unit ))

remove(output_DM)

# Selection Performance 
select_perf <- function( selected, truth ){
  
  if( any( ! selected %in% c( 0, 1 ) ) ) {
    stop("Bad input: selected should be zero or one")
  }
  if( any( ! truth %in% c( 0, 1 ) ) ) {
    stop("Bad input: truth should be zero or one")
  }
  select <- which( selected == 1 )
  not_selected <- which( selected == 0 )
  included <- which( truth == 1 )
  excluded <- which( truth == 0 )
  
  TP <- sum( select %in% included )
  TN <- sum( not_selected %in% excluded )
  FP <- sum( select %in% excluded )
  FN <- sum( not_selected %in% included )
  sensitivity <- TP/( FN + TP )
  specificity <- TN/( FP + TN )
  mcc <- ( TP*TN - FP*FN )/(sqrt( TP + FP )*sqrt(TP + FN )*sqrt(TN + FP )*sqrt(TN + FN) )
  
  return( list( sens = sensitivity, spec = specificity, mcc = mcc ) )
}

# Process selection 
eval_MMBVS_zeta_eta <- select_perf( selected = (MPPI_MMBVS_zeta_eta[ , -1 ] > 0.5)*1, truth =  (data$beta_eta[ , -1 ] != 0 )*1 )
eval_MMBVS_zeta_gamma <- select_perf( selected = (MPPI_MMBVS_zeta_gamma[ , -1 ] > 0.5)*1, truth =  (data$beta_gamma[ , -1 ] != 0 )*1 )

eval_ZIDM_zeta_eta <- select_perf( selected = (MPPI_ZIDM_zeta_eta[ , -1 ] > 0.5)*1, truth =  (data$beta_eta[ , -1 ] != 0 )*1 )
eval_ZIDM_zeta_gamma <- select_perf( selected = (MPPI_ZIDM_zeta_gamma[ , -1 ] > 0.5)*1, truth =  (data$beta_gamma[ , -1 ] != 0 )*1 )

eval_DM_zeta_gamma <- select_perf( selected = (MPPI_DM_zeta_gamma[ , -1 ] > 0.5)*1, truth =  (data$beta_gamma[ , -1 ] != 0 )*1 )


out = list( 
  
sens_MMBVS_eta <- eval_MMBVS_zeta_eta$sens,
spec_MMBVS_eta <- eval_MMBVS_zeta_eta$spec,
mcc_MMBVS_eta <- eval_MMBVS_zeta_eta$mcc,

sens_MMBVS_gamma <- eval_MMBVS_zeta_gamma$sens,
spec_MMBVS_gamma <- eval_MMBVS_zeta_gamma$spec,
mcc_MMBVS_gamma <- eval_MMBVS_zeta_gamma$mcc,

sens_ZIDM_eta <- eval_ZIDM_zeta_eta$sens,
spec_ZIDM_eta <- eval_ZIDM_zeta_eta$spec,
mcc_ZIDM_eta <- eval_ZIDM_zeta_eta$mcc,

sens_ZIDM_gamma <- eval_ZIDM_zeta_gamma$sens,
spec_ZIDM_gamma <- eval_ZIDM_zeta_gamma$spec,
mcc_ZIDM_gamma <- eval_ZIDM_zeta_gamma$mcc,

sens_DM_gamma <- eval_DM_zeta_gamma$sens,
spec_DM_gamma <- eval_DM_zeta_gamma$spec,
mcc_DM_gamma <- eval_DM_zeta_gamma$mcc,

abs_beta_eta_MicroMiss_sig = mean( abs_beta_eta_MicroMiss_sig ),  
abs_beta_eta_ZIDM_sig = mean( abs_beta_eta_ZIDM_sig ),
abs_beta_eta_MMBVS_sig = mean( abs_beta_eta_MMBVS_sig ),
cov_beta_eta_MicroMiss_sig = mean( cov_beta_eta_MicroMiss_sig ), 
cov_beta_eta_ZIDM_sig = mean( cov_beta_eta_ZIDM_sig ), 
cov_beta_eta_MMBVS_sig = mean( cov_beta_eta_MMBVS_sig ), 

abs_beta_eta_MicroMiss_non = mean( abs_beta_eta_MicroMiss_non ),
abs_beta_eta_ZIDM_non = mean( abs_beta_eta_ZIDM_non ), 
abs_beta_eta_MMBVS_non = mean( abs_beta_eta_MMBVS_non ), 
cov_beta_eta_MicroMiss_non = mean( cov_beta_eta_MicroMiss_non ),  
cov_beta_eta_ZIDM_non = mean( cov_beta_eta_ZIDM_non ),
cov_beta_eta_MMBVS_non = mean( cov_beta_eta_MMBVS_non ),

abs_beta_gamma_MicroMiss_sig = mean( abs_beta_gamma_MicroMiss_sig ),
abs_beta_gamma_ZIDM_sig = mean( abs_beta_gamma_ZIDM_sig ), 
abs_beta_gamma_DM_sig = mean( abs_beta_gamma_DM_sig ), 
abs_beta_gamma_MMBVS_sig = mean( abs_beta_gamma_MMBVS_sig ), 
cov_beta_gamma_MicroMiss_sig = mean( cov_beta_gamma_MicroMiss_sig ), 
cov_beta_gamma_ZIDM_sig = mean( cov_beta_gamma_ZIDM_sig ),
cov_beta_gamma_DM_sig = mean( cov_beta_gamma_DM_sig ),
cov_beta_gamma_MMBVS_sig = mean( cov_beta_gamma_MMBVS_sig ),

abs_beta_gamma_MicroMiss_non = mean( abs_beta_gamma_MicroMiss_non ),
abs_beta_gamma_ZIDM_non = mean( abs_beta_gamma_ZIDM_non ),
abs_beta_gamma_DM_non = mean( abs_beta_gamma_DM_non ),
abs_beta_gamma_MMBVS_non = mean( abs_beta_gamma_MMBVS_non ),
cov_beta_gamma_MicroMiss_non = mean( cov_beta_gamma_MicroMiss_non ), 
cov_beta_gamma_ZIDM_non = mean( cov_beta_gamma_ZIDM_non ), 
cov_beta_gamma_DM_non = mean( cov_beta_gamma_DM_non ), 
cov_beta_gamma_MMBVS_non = mean( cov_beta_gamma_MMBVS_non ), 

abs_theta_MicroMiss = mean( abs_theta_MicroMiss ), 
cov_theta_MicroMiss = mean( cov_theta_MicroMiss ), 
abs_theta_MMBVS = mean( abs_theta_MMBVS ), 
cov_theta_MMBVS = mean( cov_theta_MMBVS ), 

ave_gamma_MicroMiss = ave_gamma_MicroMiss,
cov_gamma_MicroMiss = cov_gamma_MicroMiss,

ave_gamma_MMBVS = ave_gamma_MMBVS,
cov_gamma_MMBVS = cov_gamma_MMBVS,

ave_gamma_ZIDM = ave_gamma_ZIDM,
cov_gamma_ZIDM = cov_gamma_ZIDM,  

ave_gamma_DM = ave_gamma_DM,
cov_gamma_DM = cov_gamma_DM,  

abs_psi_MicroMiss = mean( abs_psi_MicroMiss ),
abs_psi_ZIDM = mean( abs_psi_ZIDM ),
abs_psi_DM = mean( abs_psi_DM ),
abs_psi_MMBVS = mean( abs_psi_MMBVS ),
cov_psi_MicroMiss = mean( cov_psi_MicroMiss ), 
cov_psi_ZIDM = mean( cov_psi_ZIDM ), 
cov_psi_DM = mean( cov_psi_DM ), 
cov_psi_MMBVS = mean( cov_psi_MMBVS ), 
time_MicroMiss = as.numeric( time_MicroMiss[ 3 ] ),
time_ZIDM = as.numeric( time_ZIDM[ 3 ] ),
time_DM = as.numeric( time_DM[ 3 ] ),
time_MMBVS = as.numeric( time_MicroMissBVS[ 3 ] ))

# all_out <- list( data = data, output = output, output_ZIDM = output_ZIDM )
save( out , file = paste( "/data/koslovsk/MissMicroRevision1/setting_4_bran_large_r1 _iter_", iter, ".rda", sep = "" ) )

return( out )
  }
on.exit(stopCluster(cl)) # Terminate parallelization


write.csv(ans, "setting_4_bran_large_r1.csv")
colMeans(ans[,-1])
apply(ans[,-1],2,sd)




















