Update app.R

app.R

@@ -89,6 +89,17 @@ ui <- dashboardPage(
           box(width = 7, title = "Preview of Covariates (X)",
               status = "info", solidHeader = TRUE,
               DTOutput("covariates_table"))
+        ),
+        
+        # Performance info for data steps
+        fluidRow(
+          box(width = 12, title = "Performance Info for Data Steps", status = "warning", solidHeader = TRUE,
+              p("Time to upload X (CSV):"),
+              textOutput("time_data_upload"),
+              br(),
+              p("Time to simulate X:"),
+              textOutput("time_data_sim")
+          )
         )
       ),
       
@@ -102,7 +113,6 @@ ui <- dashboardPage(
           box(width = 4, title = "Rerandomization Parameters",
               status = "primary", solidHeader = TRUE,
               
-              # If user hasn't chosen data in tab 1, we fallback or show an error
               numericInput("n_treated", "Number Treated (n_treated)", value = 10, min = 1),
               selectInput("random_type", "Randomization Type:",
                           choices = c("Monte Carlo" = "monte_carlo",
@@ -127,6 +137,13 @@ ui <- dashboardPage(
               br(),
               plotOutput("balance_hist", height = "250px")
           )
+        ),
+        
+        # Performance info for randomization generation
+        fluidRow(
+          box(width = 12, title = "Performance Info for Generation", status = "warning", solidHeader = TRUE,
+              textOutput("time_generate")
+          )
         )
       ),
       
@@ -172,6 +189,20 @@ ui <- dashboardPage(
               br(),
               plotOutput("test_plot", height = "280px")
           )
+        ),
+        
+        # Performance info for randomization test
+        fluidRow(
+          box(width = 12, title = "Performance Info for Randomization Test", status = "warning", solidHeader = TRUE,
+              p("Time to upload Y (CSV):"),
+              textOutput("time_data_uploadY"),
+              br(),
+              p("Time to simulate Y:"),
+              textOutput("time_data_simY"),
+              br(),
+              p("Time to run randomization test:"),
+              textOutput("time_randtest")
+          )
         )
       )
       
@@ -184,18 +215,31 @@ ui <- dashboardPage(
 # ---------------------------------------------------------
 server <- function(input, output, session) {
   
+  # -- ReactiveVals to store performance times (seconds)
+  time_data_upload    <- reactiveVal(NA_real_)
+  time_data_sim       <- reactiveVal(NA_real_)
+  time_generate       <- reactiveVal(NA_real_)
+  time_data_uploadY   <- reactiveVal(NA_real_)
+  time_data_simY      <- reactiveVal(NA_real_)
+  time_randtest       <- reactiveVal(NA_real_)
+  
   # -------------------------------------------------------
   # 1. Covariate Data Handling
   # -------------------------------------------------------
   # We store the covariate matrix X in a reactiveVal for convenient reuse 
   X_data <- reactiveVal(NULL)
   
-  # Observe file input or simulation for X
+  # Observe file input (upload) for X
   observeEvent(input$file_covariates, {
     req(input$file_covariates)
     inFile <- input$file_covariates
+    
+    start_time <- Sys.time()
     df <- tryCatch(read.csv(inFile$datapath, header = TRUE),
                    error = function(e) NULL)
+    end_time <- Sys.time()
+    time_data_upload(as.numeric(difftime(end_time, start_time, units = "secs")))
+    
     if (!is.null(df)) {
       X_data(as.matrix(df))
     }
@@ -205,8 +249,13 @@ server <- function(input, output, session) {
   observeEvent(input$simulate_btn, {
     n <- input$sim_n
     p <- input$sim_p
+    
+    start_time <- Sys.time()
     # Basic simulation of N(0,1) data
     simX <- matrix(rnorm(n * p), nrow = n, ncol = p)
+    end_time <- Sys.time()
+    time_data_sim(as.numeric(difftime(end_time, start_time, units = "secs")))
+    
     X_data(simX)
   })
   
@@ -217,6 +266,25 @@ server <- function(input, output, session) {
               options = list(scrollX = TRUE, pageLength = 5))
   })
   
+  # --- Performance outputs for Data & Covariates
+  output$time_data_upload <- renderText({
+    t <- time_data_upload()
+    if (is.na(t)) {
+      "Not run yet."
+    } else {
+      paste0(round(t, 3), " seconds")
+    }
+  })
+  
+  output$time_data_sim <- renderText({
+    t <- time_data_sim()
+    if (is.na(t)) {
+      "Not run yet."
+    } else {
+      paste0(round(t, 3), " seconds")
+    }
+  })
+  
   # -------------------------------------------------------
   # 2. Generate Rerandomizations
   # -------------------------------------------------------
@@ -230,27 +298,37 @@ server <- function(input, output, session) {
            "Number treated cannot exceed total units.")
     )
     
-    # We call generate_randomizations() from fastrerandomize
-    nunits <- nrow(X_data())
-    # If user selected "exact" but it's huge, a warning would appear in the console
-    out <- tryCatch({
-      generate_randomizations(
-        n_units                  = nunits,
-        n_treated                = input$n_treated,
-        X                        = X_data(),
-        randomization_accept_prob= input$accept_prob,
-        randomization_type       = input$random_type,
-        max_draws                = if (input$random_type == "monte_carlo") input$max_draws else NULL,
-        batch_size               = if (input$random_type == "monte_carlo") input$batch_size else NULL,
-        verbose                  = FALSE
-      )
-    }, error = function(e) e)
-    
-    if (inherits(out, "error")) {
-      showNotification(paste("Error generating randomizations:", out$message), type = "error")
-      return(NULL)
-    }
-    RerandResult(out)
+    # withProgress to show progress bar in the UI
+    withProgress(message = "Computing randomizations...", value = 0, {
+      
+      # Measure time
+      start_time <- Sys.time()
+      
+      # We call generate_randomizations() from fastrerandomize
+      nunits <- nrow(X_data())
+      out <- tryCatch({
+        generate_randomizations(
+          n_units                  = nunits,
+          n_treated                = input$n_treated,
+          X                        = X_data(),
+          randomization_accept_prob= input$accept_prob,
+          randomization_type       = input$random_type,
+          max_draws                = if (input$random_type == "monte_carlo") input$max_draws else NULL,
+          batch_size               = if (input$random_type == "monte_carlo") input$batch_size else NULL,
+          verbose                  = FALSE
+        )
+      }, error = function(e) e)
+      
+      # End time
+      end_time <- Sys.time()
+      time_generate(as.numeric(difftime(end_time, start_time, units = "secs")))
+      
+      if (inherits(out, "error")) {
+        showNotification(paste("Error generating randomizations:", out$message), type = "error")
+        return(NULL)
+      }
+      RerandResult(out)
+    })
   })
   
   # Summaries of accepted randomizations
@@ -287,6 +365,16 @@ server <- function(input, output, session) {
       theme_minimal(base_size = 14)
   })
   
+  # --- Performance output for randomization generation
+  output$time_generate <- renderText({
+    t <- time_generate()
+    if (is.na(t)) {
+      "Not run yet."
+    } else {
+      paste0(round(t, 3), " seconds")
+    }
+  })
+  
   # -------------------------------------------------------
   # 3. Randomization Test
   # -------------------------------------------------------
@@ -296,10 +384,11 @@ server <- function(input, output, session) {
   observeEvent(input$simulateY_btn, {
     req(RerandResult())
     rr <- RerandResult()
-    nunits <- nrow(rr$randomizations)
     
+    nunits <- ncol(rr$randomizations)  # #units is #cols in randomizations
+    
+    start_time <- Sys.time()
     # We'll just use the first accepted randomization as the "observed" assignment
-    # in real usage, they'd pick or define their actual assignment
     obsW <- rr$randomizations[1, ]
     
     # Basic data generation: Y = X * beta + tau * W + noise
@@ -311,7 +400,10 @@ server <- function(input, output, session) {
     # random coefficients
     beta <- rnorm(ncol(Xval), 0, 1)
     linear_part <- Xval %*% beta
-    Ysim <- as.numeric(linear_part + obsW*input$true_tau + rnorm(nunits, 0, input$noise_sd))
+    Ysim <- as.numeric(linear_part + obsW * input$true_tau + rnorm(nunits, 0, input$noise_sd))
+    end_time <- Sys.time()
+    
+    time_data_simY(as.numeric(difftime(end_time, start_time, units = "secs")))
     
     Y_data(Ysim)
   })
@@ -320,7 +412,12 @@ server <- function(input, output, session) {
   observeEvent(input$file_outcomes, {
     req(input$file_outcomes)
     inFile <- input$file_outcomes
+    
+    start_time <- Sys.time()
     dfy <- tryCatch(read.csv(inFile$datapath, header = FALSE), error=function(e) NULL)
+    end_time <- Sys.time()
+    time_data_uploadY(as.numeric(difftime(end_time, start_time, units = "secs")))
+    
     if (!is.null(dfy)) {
       if (ncol(dfy) > 1) {
         showNotification("Please provide a single-column CSV for Y.", type="error")
@@ -342,32 +439,41 @@ server <- function(input, output, session) {
       return(NULL)
     }
     
-    # We'll do the test with:
-    obsW  <- rr$randomizations[1, ]
-    obsY  <- Y_data()
-    cands <- rr$randomizations
-    
-    if (length(obsY) != length(obsW)) {
-      showNotification("Dimension mismatch: Y must match number of units in the randomization.", type = "error")
-      return(NULL)
-    }
-    
-    # Call the randomization_test function
-    outTest <- tryCatch({
-      randomization_test(
-        obsW      = obsW,
-        obsY      = obsY,
-        candidate_randomizations = cands,
-        findFI    = input$findFI
-      )
-    }, error=function(e) e)
-    
-    if (inherits(outTest, "error")) {
-      showNotification(paste("Error in randomization_test:", outTest$message), type="error")
-      return(NULL)
-    }
-    
-    RandTestResult(outTest)
+    withProgress(message = "Computing randomization test...", value = 0, {
+      
+      start_time <- Sys.time()
+      
+      obsW  <- rr$randomizations[1, ]
+      obsY  <- Y_data()
+      cands <- rr$randomizations
+      
+      # Check that Y has same length as a single W
+      if (length(obsY) != length(obsW)) {
+        showNotification("Dimension mismatch: Y must match number of units in the randomization.", 
+                         type = "error")
+        return(NULL)
+      }
+      
+      # Call the randomization_test function
+      outTest <- tryCatch({
+        randomization_test(
+          obsW      = obsW,
+          obsY      = obsY,
+          candidate_randomizations = cands,
+          findFI    = input$findFI
+        )
+      }, error=function(e) e)
+      
+      end_time <- Sys.time()
+      time_randtest(as.numeric(difftime(end_time, start_time, units = "secs")))
+      
+      if (inherits(outTest, "error")) {
+        showNotification(paste("Error in randomization_test:", outTest$message), type="error")
+        return(NULL)
+      }
+      
+      RandTestResult(outTest)
+    })
   })
   
   # Display p-value and observed tau
@@ -404,29 +510,51 @@ server <- function(input, output, session) {
     )
   })
   
-  # A simple plot for the randomization distribution
+  # A simple plot for the randomization distribution 
+  # (no distribution stored by default, so just show the observed effect)
   output$test_plot <- renderPlot({
     rt <- RandTestResult()
     if (is.null(rt)) {
       return(NULL)
     }
-    # The distribution of test stats is stored in rt$stat_distribution if you used
-    #   advanced usage in the underlying code. The default version in 
-    #   randomization_test() above only returns the final p-value, so we'll do a
-    #   simpler demonstration: we only plot a vertical line for the observed effect.
-    
-    # We'll just do a line:
     obs_val <- rt$tau_obs
     
-    ggplot(data.frame(x=obs_val, y=0), aes(x, y)) +
+    ggplot(data.frame(x = obs_val, y = 0), aes(x, y)) +
       geom_point(size=4, color="red") +
       xlim(c(obs_val - abs(obs_val)*2 - 1, obs_val + abs(obs_val)*2 + 1)) +
       labs(title = "Observed Treatment Effect", 
-           subtitle = "No randomization distribution stored to plot.\n(This is a minimal demonstration.)",
            x = "Effect Size", y = "") +
       theme_minimal(base_size = 14) +
       geom_vline(xintercept = 0, linetype="dashed", color="gray40")
   })
+  
+  # --- Performance outputs for outcomes and randomization test
+  output$time_data_uploadY <- renderText({
+    t <- time_data_uploadY()
+    if (is.na(t)) {
+      "Not run yet."
+    } else {
+      paste0(round(t, 3), " seconds")
+    }
+  })
+  
+  output$time_data_simY <- renderText({
+    t <- time_data_simY()
+    if (is.na(t)) {
+      "Not run yet."
+    } else {
+      paste0(round(t, 3), " seconds")
+    }
+  })
+  
+  output$time_randtest <- renderText({
+    t <- time_randtest()
+    if (is.na(t)) {
+      "Not run yet."
+    } else {
+      paste0(round(t, 3), " seconds")
+    }
+  })
 }
 
 # ---------------------------------------------------------