Update app.R

app.R

@@ -300,120 +300,166 @@ server <- function(input, output, session) {
   # Prepare a storage structure for caching multiple results
   cachedResults <- reactiveValues(data = list())
   
+  # Track if initial load has been done
+  initialLoadDone <- reactiveVal(FALSE)
+  
   # Dynamic update of factor choices
   observe({
     if (input$case_type == "Average") {
-      factors <- colnames(FACTOR_MAT_FULL)[!colnames(FACTOR_MAT_FULL) %in% c("Office")]
+      factors <- colnames(FACTOR_MAT_FULL)[!colnames(FACTOR_MAT_FULL) %in% 
+                                             c("Office")]
     } else {
-      factors <- colnames(FACTOR_MAT_FULL)[!colnames(FACTOR_MAT_FULL) %in% c("Office", "Party.affiliation", "Party.competition")]
+      factors <- colnames(FACTOR_MAT_FULL)[!colnames(FACTOR_MAT_FULL) %in% 
+                                             c("Office", "Party.affiliation", "Party.competition")]
     }
     updateSelectInput(session, "factor", choices = factors, selected = factors[1])
   })
-
-   # Auto-compute results on startup with defaults
-  session$onFlushed(function() {
-   withProgress(message = "Loading default results...", value = 0, {
-     incProgress(0.2, detail = "Looking up precomputed results...")
-
-     # Use default values: Average case, All respondents, lambda 0.01
-     lambda_input <- 0.01
-     label <- "Case=Average, Group=All, Lambda=0.01"
-     lam_char <- gsub("\\.", "PT", as.character(lambda_input))
-     filename <- paste0("Average_All_lambda", lam_char, ".rds")
-
-     file_path <- file.path("AppResults", filename)
-     if (file.exists(file_path)) {
-       Qoptimized <- readRDS(file_path)
-       cachedResults$data[[label]] <- Qoptimized
-       incProgress(0.8, detail = "Finishing up...")
-       updateSelectInput(session, "previousResults",
-                         choices = names(cachedResults$data),
-                         selected = label)
-     }
-   })
- }, once = TRUE)
+  
+  # Auto-compute results on startup with defaults
+  observe({
+    # Only run once when the app starts
+    if (!initialLoadDone() && !is.null(input$case_type) && !is.null(input$lambda_input)) {
+      withProgress(message = "Loading default results...", value = 0, {
+        incProgress(0.2, detail = "Looking up precomputed results...")
+        
+        # Use default values
+        case_type <- "Average"
+        respondent_group <- "All"
+        lambda_input <- 0.01
+        
+        label <- paste("Case=Average, Group=All, Lambda=0.01", sep="")
+        lam_char <- gsub("\\.", "PT", as.character(lambda_input))
+        filename <- paste0("Average_All_lambda", lam_char, ".rds")
+        
+        # Read the matching pre-computed .rds file from disk
+        file_path <- file.path("AppResults", filename)
+        
+        if (file.exists(file_path)) {
+          Qoptimized <- readRDS(file_path)
+          
+          # Store the loaded results in our reactive cache
+          cachedResults$data[[label]] <- Qoptimized
+          
+          incProgress(0.8, detail = "Finishing up...")
+          
+          # Update the choice list for previous results
+          updateSelectInput(session, "previousResults",
+                            choices = names(cachedResults$data),
+                            selected = label)
+          
+          # Mark initial load as done
+          initialLoadDone(TRUE)
+        }
+      })
+    }
+  })
   
   # Generate a new result and cache it
-  # -- In app_ono.R, inside `server` definition --
   observeEvent(input$compute, {
-  withProgress(message = "Retrieving results...", value = 0, {
-    incProgress(0.2, detail = "Looking up precomputed results...")
-    
-    # Isolate input values to prevent reactive dependencies
-    case_type <- isolate(input$case_type)
-    respondent_group <- isolate(input$respondent_group)
-    lambda_input <- isolate(input$lambda_input)
-    
-    # Construct a human-readable label
-    if (case_type == "Average") {
-      label <- paste("Case=Average, Group=", respondent_group,
-                     ", Lambda=", lambda_input, sep="")
-      lam_char <- gsub("\\.", "PT", as.character(lambda_input))
-      filename <- paste0("Average_", respondent_group,
-                         "_lambda", lam_char, ".rds")
-    } else {
-      label <- paste("Case=Adversarial, Lambda=", lambda_input, sep="")
-      lam_char <- gsub("\\.", "PT", as.character(lambda_input))
-      filename <- paste0("Adversarial_lambda", lam_char, ".rds")
-    }
-    
-    # Read the matching pre-computed .rds file from disk
-    file_path <- file.path("AppResults", filename)
-    Qoptimized <- readRDS(file_path)
-    
-    # Store the loaded results in our reactive cache
-    cachedResults$data[[label]] <- Qoptimized
-    
-    incProgress(0.8, detail = "Finishing up...")
-    
-    # Update the choice list for previous results
-    updateSelectInput(session, "previousResults", 
-                      choices = names(cachedResults$data),
-                      selected = label)
+    withProgress(message = "Retrieving results...", value = 0, {
+      incProgress(0.2, detail = "Looking up precomputed results...")
+      
+      # Don't isolate - let reactive dependencies work
+      case_type <- input$case_type
+      respondent_group <- input$respondent_group
+      lambda_input <- input$lambda_input
+      
+      # Construct a human-readable label
+      if (case_type == "Average") {
+        label <- paste("Case=Average, Group=", respondent_group,
+                       ", Lambda=", lambda_input, sep="")
+        lam_char <- gsub("\\.", "PT", as.character(lambda_input))
+        filename <- paste0("Average_", respondent_group,
+                           "_lambda", lam_char, ".rds")
+      } else {
+        label <- paste("Case=Adversarial, Lambda=", lambda_input, sep="")
+        lam_char <- gsub("\\.", "PT", as.character(lambda_input))
+        filename <- paste0("Adversarial_lambda", lam_char, ".rds")
+      }
+      
+      # Read the matching pre-computed .rds file from disk
+      file_path <- file.path("AppResults", filename)
+      
+      if (file.exists(file_path)) {
+        Qoptimized <- readRDS(file_path)
+        
+        # Store the loaded results in our reactive cache
+        cachedResults$data[[label]] <- Qoptimized
+        
+        incProgress(0.8, detail = "Finishing up...")
+        
+        # Update the choice list for previous results
+        # Use immediate = TRUE to ensure the update happens right away
+        isolate({
+          updateSelectInput(session, "previousResults",
+                            choices = names(cachedResults$data),
+                            selected = label)
+        })
+        
+      } else {
+        showNotification(paste("Results file not found:", filename), 
+                         type = "error", duration = 5)
+      }
+    })
   })
-}, ignoreInit = TRUE)
   
   # Reactive to pick the result the user wants to display
   selectedResult <- reactive({
-    validate(
-      need(input$previousResults != "", "No result computed or selected yet.")
-    )
-    cachedResults$data[[input$previousResults]]
+    req(input$previousResults)
+    req(length(cachedResults$data) > 0)
+    
+    # Ensure the selected result exists
+    if (input$previousResults %in% names(cachedResults$data)) {
+      cachedResults$data[[input$previousResults]]
+    } else {
+      NULL
+    }
   })
   
   # Render strategy plot
   output$strategy_plot <- renderPlot({
-    req(selectedResult())
+    result <- selectedResult()
+    req(result)
+    
     factor_name <- input$factor
-    pi_star_list <- selectedResult()$pi_star_point
-    pi_star_se_list <- selectedResult()$pi_star_se
-    n_strategies <- selectedResult()$n_strategies
-    plot_factor(pi_star_list = pi_star_list, 
-                pi_star_se_list = pi_star_se_list, 
-                factor_name = factor_name, 
+    pi_star_list <- result$pi_star_point
+    pi_star_se_list <- result$pi_star_se
+    n_strategies <- result$n_strategies
+    
+    plot_factor(pi_star_list = pi_star_list,
+                pi_star_se_list = pi_star_se_list,
+                factor_name = factor_name,
                 n_strategies = n_strategies)
   })
   
   # Render Q value
   output$q_value <- renderText({
-    req(selectedResult())
-    q_point <- selectedResult()$Q_point
-    q_se <- selectedResult()$Q_se
+    result <- selectedResult()
+    req(result)
+    
+    q_point <- result$Q_point
+    q_se <- result$Q_se
     show_se <- length(q_se) > 0
+    
     if(show_se){ show_se <- q_se > 0 }
-    if(!show_se){ render_text <- paste("Estimated Q Value:", sprintf("%.3f", q_point)) }
-    if(show_se){ render_text <- paste("Estimated Q Value:", sprintf("%.3f ± %.3f", q_point, 1.96 * q_se)) }
-    sprintf("%s (Runtime: %.3f s)", 
+    
+    if(!show_se){ 
+      render_text <- paste("Estimated Q Value:", sprintf("%.3f", q_point)) 
+    } else { 
+      render_text <- paste("Estimated Q Value:", sprintf("%.3f ± %.3f", q_point, 1.96 * q_se)) 
+    }
+    
+    sprintf("%s (Runtime: %.3f s)",
             render_text,
-            selectedResult()$runtime_seconds)
+            result$runtime_seconds)
   })
   
   # Show which set of parameters (label) is currently selected
   output$selection_summary <- renderText({
+    req(input$previousResults)
     input$previousResults
   })
 }
 
 # Run the app
-shinyApp(ui, server)
-
+shinyApp(ui, server)