alocar_ucs -> orce

rename relatorio functions

NAMESPACE

@@ -2,18 +2,18 @@
 
 export(ToTitleCasePT)
 export(add_coordinates)
-export(alocar_ucs)
-export(alocar_ucs_dt)
 export(calcula_diarias)
 export(calcula_distancias)
 export(capitalizar)
 export(fmt_nums)
 export(gt1)
-export(limpar_cache_alocar_ucs)
+export(limpar_cache_orce)
 export(map_uc_agencias)
 export(nomear_colunas)
-export(plano_municipios)
+export(orce)
+export(orce_dt)
 export(ponto_densidade)
 export(print_gt)
+export(relatorio_municipios)
+export(relatorio_planos)
 export(rename_ibge)
-export(report_plans)

R/limpar_cache_alocar_ucs.R → R/limpar_cache_orce.R

@@ -1,6 +1,6 @@
 #' Limpa o cache de alocações
 #'
-#' Remove todos os resultados em cache da função alocar_ucs.
+#' Remove todos os resultados em cache da função orce.
 #' Útil quando você quer liberar espaço em disco ou garantir
 #' que novos cálculos sejam realizados do zero.
 #'
@@ -12,10 +12,10 @@
 #' @examples
 #' \dontrun{
 #' # Limpa todo o cache de alocações anteriores
-#' limpar_cache_alocar_ucs()
+#' limpar_cache_orce()
 #' }
-limpar_cache_alocar_ucs <- function(force = FALSE) {
-  cache_dir <- file.path(package$cache_dir, "alocar_ucs")
+limpar_cache_orce <- function(force = FALSE) {
+  cache_dir <- file.path(package$cache_dir, "orce")
   if (dir.exists(cache_dir)) {
     # Calcula o tamanho total dos arquivos antes de remover
     arquivos <- list.files(cache_dir, recursive = TRUE, full.names = TRUE)
@@ -34,7 +34,7 @@ limpar_cache_alocar_ucs <- function(force = FALSE) {
     }
 
     # Apaga o cache
-    memoise::forget(alocar_ucs)
+    memoise::forget(orce)
     message(sprintf("Cache limpo. Espaço em disco liberado."))
     return(invisible(TRUE))
   } else {

R/onLoad.R

@@ -14,9 +14,9 @@ package <- new.env(parent = emptyenv())
   package$name <- "orce"
   # local cache dir
   package$cache_dir <- tools::R_user_dir(package$name, which = 'cache')
-  dir.create(file.path(package$cache_dir, "alocar_ucs"), showWarnings = FALSE, recursive = TRUE)
+  dir.create(file.path(package$cache_dir, "orce"), showWarnings = FALSE, recursive = TRUE)
   dir.create(file.path(package$cache_dir, "get_map"), showWarnings = FALSE, recursive = TRUE)
-  alocar_ucs_mem <<- memoise::memoise(.alocar_ucs_impl, cache = cachem::cache_disk(dir = file.path(package$cache_dir, "alocar_ucs")))
+  orce_mem <<- memoise::memoise(.orce_impl, cache = cachem::cache_disk(dir = file.path(package$cache_dir, "orce")))
   get_map_mem <<- memoise::memoise(ggmap::get_map, cache = cachem::cache_disk(dir = file.path(package$cache_dir, "get_map")))
 }
 

R/alocar_ucs.R → R/orce.R

@@ -68,7 +68,7 @@
 #' }
 #'
 #' @export
-alocar_ucs <- function(ucs,
+orce <- function(ucs,
                        agencias = data.frame(agencia_codigo = unique(ucs$agencia_codigo),
                                              dias_coleta_agencia_max = Inf,
                                              custo_fixo = 0),
@@ -126,23 +126,23 @@ alocar_ucs <- function(ucs,
 
   if (use_cache) {
     # Verifica se existe cache para esses argumentos
-    is_cached <- do.call(memoise::has_cache(alocar_ucs_mem), args)
+    is_cached <- do.call(memoise::has_cache(orce_mem), args)
 
     if (is_cached) {
       cli::cli_alert_success("Usando resultado em cache para estes parâmetros.")
     } else {
       cli::cli_alert_info("Calculando e armazenando resultado em cache.")
     }
-    do.call(alocar_ucs_mem, args)
+    do.call(orce_mem, args)
   } else {
     cli::cli_alert_info("Calculando sem usar cache.")
-    do.call(.alocar_ucs_impl, args)
+    do.call(.orce_impl, args)
   }
 }
 
 
 #' @keywords internal
-.alocar_ucs_impl <- function(ucs,
+.orce_impl <- function(ucs,
                              agencias,
                              alocar_por,
                              custo_litro_combustivel,
@@ -358,7 +358,6 @@ alocar_ucs <- function(ucs,
       dplyr::select(-i) |>
       as.matrix()
   }
-
   # Criar matrizes de custos
   transport_cost_i_j <- make_i_j(x = dist_i_agencias, col = "custo_deslocamento_com_troca")
   diarias_i_j <- make_i_j(x = dist_i_agencias, col = "total_diarias")
@@ -460,15 +459,15 @@ alocar_ucs <- function(ucs,
   # Criar resultados para alocação ótima
   resultado_ucs_otimo <- dist_uc_agencias|>
     dplyr::inner_join(matching, by=c("i", "j"))|>
-    dplyr::left_join(ucs |> dplyr::distinct(uc, dplyr::pick(alocar_por)), by = "uc")|>
+    dplyr::left_join(ucs |> dplyr::distinct(dplyr::pick(dplyr::all_of(c("uc", alocar_por)))), by = "uc")|>
     dplyr::left_join(indice_t, by="t")|>
     dplyr::select(-i,-j,-t, -custo_deslocamento_com_troca)
 
   # Criar resultados para jurisdição
   resultado_ucs_jurisdicao <- dist_uc_agencias |>
     dplyr::filter(agencia_codigo_jurisdicao == agencia_codigo)|>
     dplyr::select(-agencia_codigo_jurisdicao, -j, -custo_troca_jurisdicao) |>
-    dplyr::left_join(ucs |> dplyr::distinct(uc, dplyr::pick(alocar_por)), by = c("uc"))|>
+    dplyr::left_join(ucs |> dplyr::distinct(dplyr::pick(dplyr::all_of(c("uc", alocar_por)))), by = c("uc"))|>
     dplyr::left_join(indice_t, by="t")|>
     dplyr::select(-i,-t)
 

R/report_funs.R

@@ -43,7 +43,7 @@ gt1 <- function(..., decimal_pct=1, decimal_currency=0, decimal_num=2) gt::gt(..
 
 
 #' @export
-plano_municipios <- function(r) {
+relatorio_municipios <- function(r) {
   vs <- c("municipio_nome", 'agencia_nome','custo_total', 'n_ucs', 'total_diarias', 'custo_diarias', 'custo_combustivel', 'distancia_total_km', 'custo_deslocamento',  'custo_fixo', 'entrevistadores', "agencia_codigo", "municipio_codigo")
   r1 <- r$resultado_ucs_otimo|>
     dplyr::full_join(r$resultado_ucs_jurisdicao, by=c("uc", "agencia_codigo_jurisdicao"="agencia_codigo"), suffix=c("", "_jurisdicao"))|>
@@ -58,7 +58,7 @@ plano_municipios <- function(r) {
 
 
 #' @export
-report_plans <- function(r, level="uc") {
+relatorio_planos <- function(r, level="uc") {
   levels <- dplyr::if_else(level=="uc", "ucs", "municipios")
   nlevels <- paste0("n_", levels)
   vs <- c('agencia_codigo', 'agencia_nome', 'custo_total',
@@ -93,12 +93,15 @@ report_plans <- function(r, level="uc") {
     dplyr::full_join(trocas, by=c("agencia_codigo"="agencia_codigo"))|>
     dplyr::select(any_of(dplyr::matches(vs)))|>
     dplyr::left_join(agencias_bdo|>sf::st_drop_geometry()|>dplyr::select(agencia_codigo, agencia_nome))|>
-    dplyr::mutate(agencia_nome=capitalizar(agencia_nome),
-                  agencia_nome_rec=dplyr::case_when(
-      (perde==0)&(recebe==0) ~ "Agências sem alteração*",
-      dplyr::coalesce(n_otimo,0) ==0 ~ "Agências excluídas**",
+    dplyr::mutate(
+      n_otimo=dplyr::coalesce(n_otimo,0),
+      sem_alteracao=(perde==0)&(recebe==0),
+      agencia_nome=capitalizar(agencia_nome),
+      agencia_nome_rec=dplyr::case_when(
+      sem_alteracao&(sum(sem_alteracao)>1) ~ "Agências sem alteração*",
+      (n_otimo==0)&(sum(n_otimo==0)>1) ~ "Agências excluídas**",
       TRUE ~ agencia_nome
-    ))|>
+    ), sem_alteracao=NULL)|>
     dplyr::group_by(agencia_nome_rec)|>
     dplyr::summarise(dplyr::across(dplyr::where(is.numeric), ~sum(.x, na.rm=TRUE)), agencias_nomes=paste(agencia_nome, collapse=", "))|>
     dplyr::arrange(grepl("\\*", agencia_nome_rec), agencia_nome_rec, desc(n_jurisdicao))|>

README.Rmd

@@ -17,7 +17,7 @@ The `orce` package is an R package designed to optimize the allocation of statis
 
 1. **Routing and Geocoding**: Determining the optimal routes between UCs and agencies requires accurate location data. The `orce` package leverages the CNEFE (National Register of Addresses for Statistical Purposes) database to obtain precise coordinates for each UC, prioritizing high-density areas within census tracts to ensure accessibility and representativeness. The `ponto_setor_densidade` function aids in identifying these representative locations.
 
-2. **Allocation Optimization**: The core of the `orce` package is its allocation optimization algorithm. It employs mixed-integer linear programming to minimize the overall cost of data collection, considering factors like travel distances, travel time, and fixed agency costs. The `alocar_ucs` function implements this optimization, allowing for flexible constraints on agency capacity and location preferences.
+2. **Allocation Optimization**: The core of the `orce` package is its allocation optimization algorithm. It employs mixed-integer linear programming to minimize the overall cost of data collection, considering factors like travel distances, travel time, and fixed agency costs. The `orce` function implements this optimization, allowing for flexible constraints on agency capacity and location preferences.
 
 3. **Cost Calculation**: Accurately estimating the cost of data collection involves more than just distances and travel time. The `orce` package incorporates knowledge of administrative boundaries to determine whether "diárias" (travel allowances) are applicable. This nuanced cost calculation ensures that the optimization results reflect the true financial implications of different allocation scenarios.
 
@@ -69,7 +69,7 @@ dists <- distancias_agencias_municipios_osrm |>
   dplyr::semi_join(agencias, by = "agencia_codigo") |>
   dplyr::mutate(diaria_pernoite = duracao_horas > 1.5, uc = municipio_codigo)
 
-m <- alocar_ucs(ucs = ucs_municipios, agencias = agencias, dias_coleta_entrevistador_max = 14, distancias_ucs = dists, remuneracao_entrevistador = 0, rel_tol = 0.01)
+m <- orce(ucs = ucs_municipios, agencias = agencias, dias_coleta_entrevistador_max = 14, distancias_ucs = dists, remuneracao_entrevistador = 0, rel_tol = 0.01)
 
 report_plans(m)
 ```
@@ -81,7 +81,7 @@ O pacote `orce` é um pacote R projetado para otimizar a alocação de unidades
 
 1. **Roteamento e Geocodificação**: A determinação das rotas ideais entre as UCs e as agências requer dados de localização precisos. O pacote `orce` utiliza o banco de dados do CNEFE (Cadastro Nacional de Endereços para Fins Estatísticos) para obter coordenadas precisas para cada UC, priorizando áreas de alta densidade dentro dos setores censitários para garantir acessibilidade e representatividade. A função ponto_setor_densidade auxilia na identificação desses locais representativos.
 
-2. **Otimização da Alocação** O núcleo do pacote `orce` é seu algoritmo de otimização de alocação. Ele emprega programação linear inteira mista para minimizar o custo total da coleta de dados, considerando fatores como distâncias de viagem, tempo de viagem e custos fixos das agências. A função alocar_ucs implementa essa otimização, permitindo restrições flexíveis na capacidade da agência e nas preferências de localização.
+2. **Otimização da Alocação** O núcleo do pacote `orce` é seu algoritmo de otimização de alocação. Ele emprega programação linear inteira mista para minimizar o custo total da coleta de dados, considerando fatores como distâncias de viagem, tempo de viagem e custos fixos das agências. A função orce implementa essa otimização, permitindo restrições flexíveis na capacidade da agência e nas preferências de localização.
 
 3. **Cálculo de Custos** Estimar com precisão o custo da coleta de dados envolve mais do que apenas distâncias e tempo de viagem. O pacote `orce` incorpora o conhecimento das fronteiras administrativas para determinar se as "diárias" (ajudas de custo para viagens) são aplicáveis. Esse cálculo de custo diferenciado garante que os resultados da otimização reflitam as verdadeiras implicações financeiras de diferentes cenários de alocação.