

######################### 
# 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_sparse_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:50, # 50 is the number of simulations
                .combine=rbind, .packages = c( "Rcpp", "RcppArmadillo",  "MCMCpack", "dirmult","mvtnorm", "MicroMiss"), .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 <- 10
    data <- simulate_MicroMiss( missclass_prob = c( 0.60, 0.20, 0.20 ) , N = 50, T. = 50, C. = 50, P_eta = 2, P_gamma = 2, 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 ) )
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 <- 5
sigma2_beta_gamma <- 5

# 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 

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_sparse_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] ) )[1:(active_cov)]  # mean( abs_beta_eta_MicroMiss_sig )
 
abs_beta_eta_MicroMiss_non <- c( abs( post_beta_eta_MicroMiss[,-1] - data$beta_eta_true[,-1] ) )[(active_cov + 1):data$T.]  # 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[1:(active_cov)]
 
cov_beta_eta_MicroMiss_non <-  cov_beta_eta_MicroMiss[(active_cov + 1):data$T.]
 
 
# 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] ) )[1:(active_cov)]  # mean( abs_beta_gamma_MicroMiss_sig )

abs_beta_gamma_MicroMiss_non <- c( abs( post_beta_gamma_MicroMiss[,-1] - data$beta_gamma_true[,-1] ) )[(active_cov + 1):data$T.]  # 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[1:(active_cov)] # mean( cov_beta_gamma_MicroMiss_sig )
 
cov_beta_gamma_MicroMiss_non <-  cov_beta_gamma_MicroMiss[(active_cov + 1):data$T.] # 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 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 <- matrix( 0, data$N, data$T. )
for( i in 1:data$N ){
  for( t in 1:data$T. ){
    true_gamma_unit[i,t] <- effect( beta_gamma_true, X_gamma[ i, ], t, 2) 
  }
}

# Beta gamma MicroMISS
MCMC_gamma_unit <- array( 0, dim = c( data$N, dim(output$beta_gamma)[1], samples ) ) 
MCMC_gamma_unit <- effects(output$beta_gamma, X_gamma, data$T., samples ) 

post_beta_gamma_MicroMiss <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), mean )  
post_beta_gamma_MicroMiss_upper <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
post_beta_gamma_MicroMiss_lower <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.025 ) } ) 

ave_gamma_MicroMiss <- mean( abs(post_beta_gamma_MicroMiss - true_gamma_unit ) )
cov_gamma_MicroMiss <- mean( c( post_beta_gamma_MicroMiss_upper > true_gamma_unit & post_beta_gamma_MicroMiss_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 )
time_ZIDM <- proc.time() - ptm_ZIDM

names( output_ZIDM ) <- c( "alpha_t", "zeta", "beta_eta", "omega_eta", "beta_gamma")

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

# 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] ) )[1:(active_cov)]   # mean( abs_beta_eta_ZIDM_sig )

abs_beta_eta_ZIDM_non <- c( abs( post_beta_eta_ZIDM[,-1] - data$beta_eta_true[,-1] ) )[(active_cov + 1):data$T.]   # 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[1:(active_cov)]

cov_beta_eta_ZIDM_non <-  cov_beta_eta_ZIDM[(active_cov + 1):data$T.]
 
# 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] ) )[1:(active_cov)]   # mean( abs_beta_gamma_ZIDM_sig )

abs_beta_gamma_ZIDM_non <- c( abs( post_beta_gamma_ZIDM[,-1] - data$beta_gamma_true[,-1] ) )[(active_cov + 1):data$T.] # 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[1:(active_cov)] # mean( cov_beta_gamma_ZIDM_sig )

cov_beta_gamma_ZIDM_non <-  cov_beta_gamma_ZIDM[(active_cov + 1):data$T.] # 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
MCMC_gamma_unit <- array( 0, dim = c( data$N, dim(output_ZIDM$beta_gamma)[1], samples ) ) 

MCMC_gamma_unit <- effects(output_ZIDM$beta_gamma, X_gamma, data$T., samples ) 

post_beta_gamma_ZIDM <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), mean )  
post_beta_gamma_ZIDM_upper <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
post_beta_gamma_ZIDM_lower <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.025 ) } ) 

ave_gamma_ZIDM <- mean( abs(post_beta_gamma_ZIDM - true_gamma_unit ) )
cov_gamma_ZIDM <- mean( c( post_beta_gamma_ZIDM_upper > true_gamma_unit & post_beta_gamma_ZIDM_lower < true_gamma_unit ))

remove(output_ZIDM)

ptm_DM <- proc.time() 
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")

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


# 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] ) )[1:(active_cov)]   # mean( abs_beta_gamma_ZIDM_sig )

abs_beta_gamma_DM_non <- c( abs( post_beta_gamma_DM[,-1] - data$beta_gamma_true[,-1] ) )[(active_cov + 1):data$T.] # 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[1:(active_cov)] # mean( cov_beta_gamma_ZIDM_sig )

cov_beta_gamma_DM_non <-  cov_beta_gamma_DM[(active_cov + 1):data$T.] # 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
MCMC_gamma_unit <- array( 0, dim = c( data$N, dim(output_DM$beta_gamma)[1], samples ) ) 

MCMC_gamma_unit <- effects(output_DM$beta_gamma, X_gamma, data$T., samples ) 

post_beta_gamma_DM <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), mean )  
post_beta_gamma_DM_upper <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.975 ) } )  
post_beta_gamma_DM_lower <- apply( MCMC_gamma_unit[ , , (floor(samples)/2 + 1):(floor(samples)) ] , c(1,2), function( x ){ quantile( x , 0.025 ) } ) 

ave_gamma_DM <- mean( abs(post_beta_gamma_DM - true_gamma_unit ) )
cov_gamma_DM <- mean( c( post_beta_gamma_DM_upper > true_gamma_unit & post_beta_gamma_DM_lower < true_gamma_unit ))

remove(output_DM)

out = list( 
abs_beta_eta_MicroMiss_sig = mean( abs_beta_eta_MicroMiss_sig ),  
abs_beta_eta_ZIDM_sig = mean( abs_beta_eta_ZIDM_sig ),
cov_beta_eta_MicroMiss_sig = mean( cov_beta_eta_MicroMiss_sig ), 
cov_beta_eta_ZIDM_sig = mean( cov_beta_eta_ZIDM_sig ), 

abs_beta_eta_MicroMiss_non = mean( abs_beta_eta_MicroMiss_non ),
abs_beta_eta_ZIDM_non = mean( abs_beta_eta_ZIDM_non ), 
cov_beta_eta_MicroMiss_non = mean( cov_beta_eta_MicroMiss_non ),  
cov_beta_eta_ZIDM_non = mean( cov_beta_eta_ZIDM_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 ), 
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 ),

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 ),
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 ), 

abs_theta_MicroMiss = mean( abs_theta_MicroMiss ), 
cov_theta_MicroMiss = mean( cov_theta_MicroMiss ), 

ave_gamma_MicroMiss = ave_gamma_MicroMiss,
cov_gamma_MicroMiss = cov_gamma_MicroMiss,

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 ),
cov_psi_MicroMiss = mean( cov_psi_MicroMiss ), 
cov_psi_ZIDM = mean( cov_psi_ZIDM ), 
cov_psi_DM = mean( cov_psi_DM ), 
time_MicroMiss = as.numeric( time_MicroMiss[ 3 ] ),
time_ZIDM = as.numeric( time_ZIDM[ 3 ] ),
time_DM = as.numeric( time_DM[ 3 ] ) )

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

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


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