leppott/ContDataSumViz
Create Visualizations of Continuous Monitoring Data

Package index
Search the leppott/ContDataSumViz package
Vignettes
Functions
6
Source code
45
Man pages
3
Home
/
GitHub
/
leppott/ContDataSumViz
/

In leppott/ContDataSumViz: Create Visualizations of Continuous Monitoring Data 

# Options
knitr::opts_chunk$set(results = 'asis', echo = FALSE, warning = FALSE)

# Packages
# library(knitr)
# library(DT)
# library(plotly)
# library(ggplot2)
# library(dplyr)

# Data files
strFile <- file.path(dir_data, file_data)
data.import <- read.csv(strFile)

# Excle Output
# Sheets to List
 ls_excel <- list()
NOTES <- data.frame(matrix(ncol = 3, nrow = 0))
ls_excel[["NOTES"]] <- NOTES
## add additional sheets as the tables are created
### re-used names so cannot add at the end

DATA FILE INFORMATION

 # Report Info
  myReportDate <- format(Sys.Date(),ContData.env$myFormat.Date)
  cat(paste("**Report Date:** ",myReportDate,"\n\n",sep = ""))
  myUser <- Sys.getenv("USERNAME")
  cat(paste("**Generated By:** ",myUser,"\n\n",sep = ""))

  #filename
  cat("**Filename:** ",file_data,"\n\n",sep="")
  mySiteID <- data.import[1, ContData.env$myName.SiteID]

  #cat(paste("**SiteID:** ",mySiteID,"\n\n",sep=""))

  myNumRecords <- nrow(data.import) 
  # 20170228, mod from records 10 and 11 to half way point

  # myTimeDiff <- difftime(data.import[10,ContData.env$myName.DateTime]
  #,data.import[11,ContData.env$myName.DateTime],units="mins")
  #x <- data.import[,ContData.env$myName.DateTime]
  myT <- strptime(data.import[,ContData.env$myName.DateTime]
                  ,format = ContData.env$myFormat.DateTime)
  myTimeDiff.all <- difftime(myT[-1],myT[-length(myT)], units = "mins")
  myTimeDiff <- median(as.vector(myTimeDiff.all), na.rm = TRUE)
  cat(paste("\n\n**Period of Record, Actual:** "
            , min(data.import[,ContData.env$myName.Date])
            , " to "
            , max(data.import[,ContData.env$myName.Date])
            , "\n\n"
            , sep = ""))

  cat(paste("**Recording Interval (estimated):** "
            , myTimeDiff[1]
            , " minutes\n\n"
            , sep = ""))

   myParameters.ALL     <- ContData.env$myNames.DataFields[ContData.env$myNames.DataFields 
                                                %in% names(data.import) == TRUE] 
   myParameters.Lab.ALL <- ContData.env$myNames.DataFields.Lab[ContData.env$myNames.DataFields 
                                                %in% names(data.import) == TRUE]
   # Filter out Discrete
   myParameters     <- myParameters.ALL[!grepl(ContData.env$myPrefix.Discrete,myParameters.ALL)]
   myParameters.Lab <- myParameters.Lab.ALL[
                                           !grepl(ContData.env$myPrefix.Discrete
                                                   ,myParameters.Lab.ALL)]


 #cat("**Parameters:** ",paste(myParameters.Lab,", ",sep=""),"\n\n",sep="")
  # above line not working, preventing pandoc conversion to WORD
  #cat("**Included Parameters:** \n\n")
  cat("**Parameters Included:** "
      , paste(myParameters, ", ", sep = "")
      , "\n\n"
      , sep = "")

DATA SUMMARY, OVERALL

# Plot of range of data
df_plot <- unique(data.import[, ContData.env$myName.Date, FALSE])
names(df_plot) <- "Date"
df_plot[, "Date"] <- as.Date(df_plot[, "Date"])
# julian dates
df_plot$Year <- format(df_plot[, "Date"], "%Y")
df_plot$j <- as.numeric(format(df_plot[, "Date"], "%j"))
df_plot$Date_Plot <- as.Date(as.numeric(format(df_plot[, "Date"]
                                                        , "%j")) - 1
                                      , origin = as.Date("2004-01-01"))
# plot
cap <- "Thick line is a date where data is present for any parameter."
p_years <- ggplot2::ggplot(data = df_plot
                           , ggplot2::aes(y = Year)) +
  ggplot2::scale_x_date(date_labels = "%b%d"
                        , limits = as.Date(c("2004-01-01", "2004-12-31"))
                        , date_breaks = "1 month"
                        , expand = c(0, 0)) + 
  ggplot2::labs(x = "Date"
                , y = "Year"
                , title = "Data by Year and Dates"
                , caption = cap) + 
  ggplot2::geom_line(ggplot2::aes(x = Date_Plot
                                  , y = Year)
                     , size = 2
                     , na.rm = TRUE) +
  ggplot2::theme_bw()
p_years
cat("\n\n")


      # Convert time interval (minutes) to number per day
      records.expected <- round(24 * 60 / as.numeric(myTimeDiff[1]), 1)

      cat(paste("Estimated number of records per day is "
                , records.expected
                , "."
                , sep = ""))
        cat("\n\n")

    cap <- "Number of records by year and month (with totals)."

    myTable <- addmargins(table(data.import[,ContData.env$myName.Yr]
                                ,data.import[,ContData.env$myName.Mo]
                                , useNA = "ifany"))
        print(knitr::kable(myTable
                           , format = "markdown"
                           , row.names = TRUE
                           , caption = cap))
    cat("\n\n")
    # Export Table to Excel
    df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
    df_myTable <- cbind(rownames(myTable), df_myTable)
    colnames(df_myTable)[1] <- ""
    name_table4list <- "AllData_Year_Month"
    ls_excel[[name_table4list]] <- df_myTable

    # DT::datatable(myTable, caption = cap)
    # cat("\n\n")

  # revert to longer table (20170228)
    cap <- "Number of records by day and month (with totals)."
    myTable <- addmargins(table(data.import[,ContData.env$myName.Day]
                                ,data.import[,ContData.env$myName.Mo]
                                , useNA = "ifany"))
        print(knitr::kable(myTable
                           , format = "markdown"
                           , row.names = TRUE
                           , caption = cap))
    cat("\n\n") 
    # Add Table to Excel
    # Export Table to Excel
    df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
    df_myTable <- cbind(rownames(myTable), df_myTable)
    colnames(df_myTable)[1] <- ""
    name_table4list <- "AllData_Day_Month"
    ls_excel[[name_table4list]] <- df_myTable
#     
#     pandoc.table(myTable.month.day.rec.GT15,style="rmarkdown")
#    
#     
    myTable.month.day.rec <- table(data.import[,ContData.env$myName.Mo]
                                   ,data.import[,ContData.env$myName.Day]
                                   , useNA = "ifany")
#     use apply function to count number of records not equal to the expected value
    cat("\n\n")

    #
    myTable.DateTime.N <- aggregate(data.import[,ContData.env$myName.SiteID]  
                                    ~ data.import[,ContData.env$myName.DateTime]
                                    , data = data.import
                                    , FUN = length)
    # myTable <- myTable.DateTime.N[myTable.DateTime.N[,ContData.env$myName.SiteID]!=1,]
    # cat(paste0("Date and time records with more than one entry; N=",nrow(myTable),". Duplicate date.time records are shown below."))
    # cat("\n")
    #   print(knitr::kable(myTable, format="markdown", row.names=TRUE))
    # mask error, 20170307

    # Missing Dates

    myDateRange.Data <- seq(as.Date(min(data.import[,ContData.env$myName.Date]))
                            ,as.Date(max(data.import[,ContData.env$myName.Date]))
                            ,by = "day")

    if (exists("fun.myData.DateRange.Start") == TRUE) {
      myDateRange.Target <- seq(as.Date(fun.myData.DateRange.Start)
                              ,as.Date(fun.myData.DateRange.End)
                              ,by = "day")
    } else {
      myDateRange.Target <- myDateRange.Data
    }

    myDateRange.Target.Missing <- myDateRange.Target[!myDateRange.Target %in% myDateRange.Data]
    cat(paste0("There are "
               , length(myDateRange.Target.Missing)
               , "dates with missing data between the min ("
               , min(myDateRange.Data)
               , ") and max("
               , max(myDateRange.Data)
               , ") for the provided data. \n\n"
               , "Below are the dates:"))
    cat("\n\n")
    print(ifelse(length(myDateRange.Target.Missing) == 0
                 , ""
                 , myDateRange.Target.Missing))

FLAGS

cat(paste("* **"
          , ContData.env$myFlagVal.Pass
          , "** = Pass,"
          , sep = ""))
cat("\n")
cat(paste("* **"
          , ContData.env$myFlagVal.Suspect
          , "** = Suspect,"
          , sep = ""))  
cat("\n")
cat(paste("* **"
          , ContData.env$myFlagVal.Fail
          , "** = Fail,"
          , sep = ""))
cat("\n")
cat(paste("* **"
          , ContData.env$myFlagVal.NoData
          , "** = No Data or Not Applicable (NA)."
          , sep = ""))

Overall flags are assigned by examining the results of the four tests below. 

cat(paste("* **"
          , ContData.env$myFlagVal.Pass
          , "** = no Fail or Suspect and at least one Pass,"
          , sep = ""))
cat("\n")
cat(paste("* **",ContData.env$myFlagVal.Suspect
          , "** = no Fail and at least one Suspect,"
          , sep = "")) 
cat("\n") 
cat(paste("* **"
          , ContData.env$myFlagVal.Fail
          , "** = at least one Fail
          , ",sep = ""))
cat("\n")
cat(paste("* **"
          , ContData.env$myFlagVal.NoData
          , "** = all tests were Missing Data."
          , sep = ""))

# Overall flags by paramter
# (maybe combine into a single table)
# skip for now
# duplicated in by parameter section for missing data
# 
# 
#      for (j in 1:length(myParameters)) {##FOR.j.START
# #       #
#        #j.num <- match(j,myParameters)
#  #   cat(paste(myParameters.Lab[j.num],"/n/n",sep=""))
#        
#        # ISSUE WITH knitr::kable INSIDE OF LOOPS
#        
#     cat(paste("## ",myParameters[j],"\n\n",sep=""))
#        colnum <- match(paste("Flag",myParameters[j],sep="."),names(data.import))
#        
#        #print(myTable.Flags.Overall <- ftable(data.import[,colnum]))
#        myTable <- addmargins(table(data.import[,colnum]
#                                    , useNA = "ifany")
#                              ,1)
#        print(knitr::kable(t(as.matrix(myTable)), format = "markdown"))
#        # future mod, 1,3,4,9 to Pass, Suspect, Fail, NA
#        # exclude=NA to get all
#        # future mod, 2nd line in table to include Percent of row total
#        # future mod, sort levels
#        
#        cat("\n\n")
#        
#      }##FOR.j.END

MISSING DATA, BY PARAMETER {.tabset}

Number of expected values is estimated but this assumes equal sampling effort in all cases. This may not be the case for many data files. 

# 3.1. Number of Records (revised 20170228)
 # Convert time interval (minutes) to number per day
records.expected <- round(24*60/as.numeric(myTimeDiff[1]),1)
cat(paste("The estimated number of records per day is "
          , records.expected
          , "."
          , sep = ""))
cat("\n\n")

The number of existing values will be shown in a heat map and the number of dates with not the expected number of records is shown in a table.

param_num <- 1

param_name <- ContData.env$myNames.DataFields[param_num]
param_lab  <- ContData.env$myNames.DataFields.Lab[param_num]

param_boo <- param_name %in% myParameters

# Create Child Chunk if parameter is present
if (param_boo) {
  # Define new environment
  child_env <- new.env()
  child_env$p_num <- param_num
  child_env$p_name <- param_name

  # knit the document and save the character output to an object
  res <- knitr::knit_child(
    "MissingData_01Child.Rmd",
    envir = child_env,
    quiet = TRUE
  )## res ~ END

  # Cat the object to make it render in your main document
  cat(res, sep = '\n')

  #~~~~~~~~~~~~~~~~~
  # Excel
  ## variables
  i <- ContData.env$myNames.DataFields[child_env$p_num]
  i.flag <- paste(ContData.env$myName.Flag, i, sep = ".")
  #
  ## Excel, Flags
  myTable <- addmargins(table(data.import[, i.flag]
                           , useNA = "ifany")
                     , 1)
  df_myTable <- as.data.frame.matrix(t(myTable))
  name_table4list <- paste0(param_name, "_Flags")
  ls_excel[[name_table4list]] <- df_myTable
  #
  ## Excel, Year Month
  myTable <- addmargins(table(data.import[,ContData.env$myName.Yr]
                          ,data.import[,ContData.env$myName.Mo]
                          , useNA = "ifany"))
  df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
  df_myTable <- cbind(rownames(myTable), df_myTable)
  colnames(df_myTable)[1] <- ""
  name_table4list <- paste0(param_name, "_Year_Month")
  ls_excel[[name_table4list]] <- df_myTable
  #
  # Table to Excel, Missing
  df_base <- data.import %>%
    dplyr::filter(!!as.name(i.flag) == "P") %>%
    dplyr::group_by(!!as.name(ContData.env$myName.MoDa)
                    , !!as.name(ContData.env$myName.Yr)) %>%
    dplyr::summarise(n = dplyr::n(), .groups = "drop")
  # munge
  df_base$MonthDay <- sprintf("%04d", df_base$MonthDay)
  # change class
  df_base$MonthDay <- as.character(df_base$MonthDay)
  df_base$Year <- as.character(df_base$Year)
  df_missing <- df_base %>%
    dplyr::filter(n != records.expected) %>%
    dplyr::select(Year, MonthDay, n) %>%
    dplyr::arrange(Year, MonthDay)
  name_table4list <- paste0(param_name, "_DaysMissing")
  ls_excel[[name_table4list]] <- df_missing
}## IF ~ END

param_num <- 2

param_name <- ContData.env$myNames.DataFields[param_num]
param_lab  <- ContData.env$myNames.DataFields.Lab[param_num]

param_boo <- param_name %in% myParameters

# Create Child Chunk if parameter is present
if (param_boo) {
  # Define new environment
  child_env <- new.env()
  child_env$p_num <- param_num
  child_env$p_name <- param_name

  # knit the document and save the character output to an object
  res <- knitr::knit_child(
    "MissingData_01Child.Rmd",
    envir = child_env,
    quiet = TRUE
  )## res ~ END

  # Cat the object to make it render in your main document
  cat(res, sep = '\n')

  #~~~~~~~~~~~~~~~~~
  # Excel
  ## variables
  i <- ContData.env$myNames.DataFields[child_env$p_num]
  i.flag <- paste(ContData.env$myName.Flag, i, sep = ".")
  #
  ## Excel, Flags
  myTable <- addmargins(table(data.import[, i.flag]
                           , useNA = "ifany")
                     , 1)
  df_myTable <- as.data.frame.matrix(t(myTable))
  name_table4list <- paste0(param_name, "_Flags")
  ls_excel[[name_table4list]] <- df_myTable
  #
  ## Excel, Year Month
  myTable <- addmargins(table(data.import[,ContData.env$myName.Yr]
                          ,data.import[,ContData.env$myName.Mo]
                          , useNA = "ifany"))
  df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
  df_myTable <- cbind(rownames(myTable), df_myTable)
  colnames(df_myTable)[1] <- ""
  name_table4list <- paste0(param_name, "_Year_Month")
  ls_excel[[name_table4list]] <- df_myTable
  #
  # Table to Excel, Missing
  df_base <- data.import %>%
    dplyr::filter(!!as.name(i.flag) == "P") %>%
    dplyr::group_by(!!as.name(ContData.env$myName.MoDa)
                    , !!as.name(ContData.env$myName.Yr)) %>%
    dplyr::summarise(n = dplyr::n(), .groups = "drop")
  # munge
  df_base$MonthDay <- sprintf("%04d", df_base$MonthDay)
  # change class
  df_base$MonthDay <- as.character(df_base$MonthDay)
  df_base$Year <- as.character(df_base$Year)
  df_missing <- df_base %>%
    dplyr::filter(n != records.expected) %>%
    dplyr::select(Year, MonthDay, n) %>%
    dplyr::arrange(Year, MonthDay)
  name_table4list <- paste0(param_name, "_DaysMissing")
  ls_excel[[name_table4list]] <- df_missing
}## IF ~ END

param_num <- 3

param_name <- ContData.env$myNames.DataFields[param_num]
param_lab  <- ContData.env$myNames.DataFields.Lab[param_num]

param_boo <- param_name %in% myParameters

# Create Child Chunk if parameter is present
if (param_boo) {
  # Define new environment
  child_env <- new.env()
  child_env$p_num <- param_num
  child_env$p_name <- param_name

  # knit the document and save the character output to an object
  res <- knitr::knit_child(
    "MissingData_01Child.Rmd",
    envir = child_env,
    quiet = TRUE
  )## res ~ END

  # Cat the object to make it render in your main document
  cat(res, sep = '\n')

  #~~~~~~~~~~~~~~~~~
  # Excel
  ## variables
  i <- ContData.env$myNames.DataFields[child_env$p_num]
  i.flag <- paste(ContData.env$myName.Flag, i, sep = ".")
  #
  ## Excel, Flags
  myTable <- addmargins(table(data.import[, i.flag]
                           , useNA = "ifany")
                     , 1)
  df_myTable <- as.data.frame.matrix(t(myTable))
  name_table4list <- paste0(param_name, "_Flags")
  ls_excel[[name_table4list]] <- df_myTable
  #
  ## Excel, Year Month
  myTable <- addmargins(table(data.import[,ContData.env$myName.Yr]
                          ,data.import[,ContData.env$myName.Mo]
                          , useNA = "ifany"))
  df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
  df_myTable <- cbind(rownames(myTable), df_myTable)
  colnames(df_myTable)[1] <- ""
  name_table4list <- paste0(param_name, "_Year_Month")
  ls_excel[[name_table4list]] <- df_myTable
  #
  # Table to Excel, Missing
  df_base <- data.import %>%
    dplyr::filter(!!as.name(i.flag) == "P") %>%
    dplyr::group_by(!!as.name(ContData.env$myName.MoDa)
                    , !!as.name(ContData.env$myName.Yr)) %>%
    dplyr::summarise(n = dplyr::n(), .groups = "drop")
  # munge
  df_base$MonthDay <- sprintf("%04d", df_base$MonthDay)
  # change class
  df_base$MonthDay <- as.character(df_base$MonthDay)
  df_base$Year <- as.character(df_base$Year)
  df_missing <- df_base %>%
    dplyr::filter(n != records.expected) %>%
    dplyr::select(Year, MonthDay, n) %>%
    dplyr::arrange(Year, MonthDay)
  name_table4list <- paste0(param_name, "_DaysMissing")
  ls_excel[[name_table4list]] <- df_missing
}## IF ~ END

param_num <- 4

param_name <- ContData.env$myNames.DataFields[param_num]
param_lab  <- ContData.env$myNames.DataFields.Lab[param_num]

param_boo <- param_name %in% myParameters

# Create Child Chunk if parameter is present
if (param_boo) {
  # Define new environment
  child_env <- new.env()
  child_env$p_num <- param_num
  child_env$p_name <- param_name

  # knit the document and save the character output to an object
  res <- knitr::knit_child(
    "MissingData_01Child.Rmd",
    envir = child_env,
    quiet = TRUE
  )## res ~ END

  # Cat the object to make it render in your main document
  cat(res, sep = '\n')

  #~~~~~~~~~~~~~~~~~
  # Excel
  ## variables
  i <- ContData.env$myNames.DataFields[child_env$p_num]
  i.flag <- paste(ContData.env$myName.Flag, i, sep = ".")
  #
  ## Excel, Flags
  myTable <- addmargins(table(data.import[, i.flag]
                           , useNA = "ifany")
                     , 1)
  df_myTable <- as.data.frame.matrix(t(myTable))
  name_table4list <- paste0(param_name, "_Flags")
  ls_excel[[name_table4list]] <- df_myTable
  #
  ## Excel, Year Month
  myTable <- addmargins(table(data.import[,ContData.env$myName.Yr]
                          ,data.import[,ContData.env$myName.Mo]
                          , useNA = "ifany"))
  df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
  df_myTable <- cbind(rownames(myTable), df_myTable)
  colnames(df_myTable)[1] <- ""
  name_table4list <- paste0(param_name, "_Year_Month")
  ls_excel[[name_table4list]] <- df_myTable
  #
  # Table to Excel, Missing
  df_base <- data.import %>%
    dplyr::filter(!!as.name(i.flag) == "P") %>%
    dplyr::group_by(!!as.name(ContData.env$myName.MoDa)
                    , !!as.name(ContData.env$myName.Yr)) %>%
    dplyr::summarise(n = dplyr::n(), .groups = "drop")
  # munge
  df_base$MonthDay <- sprintf("%04d", df_base$MonthDay)
  # change class
  df_base$MonthDay <- as.character(df_base$MonthDay)
  df_base$Year <- as.character(df_base$Year)
  df_missing <- df_base %>%
    dplyr::filter(n != records.expected) %>%
    dplyr::select(Year, MonthDay, n) %>%
    dplyr::arrange(Year, MonthDay)
  name_table4list <- paste0(param_name, "_DaysMissing")
  ls_excel[[name_table4list]] <- df_missing
}## IF ~ END

param_num <- 5

param_name <- ContData.env$myNames.DataFields[param_num]
param_lab  <- ContData.env$myNames.DataFields.Lab[param_num]

param_boo <- param_name %in% myParameters

# Create Child Chunk if parameter is present
if (param_boo) {
  # Define new environment
  child_env <- new.env()
  child_env$p_num <- param_num
  child_env$p_name <- param_name

  # knit the document and save the character output to an object
  res <- knitr::knit_child(
    "MissingData_01Child.Rmd",
    envir = child_env,
    quiet = TRUE
  )## res ~ END

  # Cat the object to make it render in your main document
  cat(res, sep = '\n')

  #~~~~~~~~~~~~~~~~~
  # Excel
  ## variables
  i <- ContData.env$myNames.DataFields[child_env$p_num]
  i.flag <- paste(ContData.env$myName.Flag, i, sep = ".")
  #
  ## Excel, Flags
  myTable <- addmargins(table(data.import[, i.flag]
                           , useNA = "ifany")
                     , 1)
  df_myTable <- as.data.frame.matrix(t(myTable))
  name_table4list <- paste0(param_name, "_Flags")
  ls_excel[[name_table4list]] <- df_myTable
  #
  ## Excel, Year Month
  myTable <- addmargins(table(data.import[,ContData.env$myName.Yr]
                          ,data.import[,ContData.env$myName.Mo]
                          , useNA = "ifany"))
  df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
  df_myTable <- cbind(rownames(myTable), df_myTable)
  colnames(df_myTable)[1] <- ""
  name_table4list <- paste0(param_name, "_Year_Month")
  ls_excel[[name_table4list]] <- df_myTable
  #
  # Table to Excel, Missing
  df_base <- data.import %>%
    dplyr::filter(!!as.name(i.flag) == "P") %>%
    dplyr::group_by(!!as.name(ContData.env$myName.MoDa)
                    , !!as.name(ContData.env$myName.Yr)) %>%
    dplyr::summarise(n = dplyr::n(), .groups = "drop")
  # munge
  df_base$MonthDay <- sprintf("%04d", df_base$MonthDay)
  # change class
  df_base$MonthDay <- as.character(df_base$MonthDay)
  df_base$Year <- as.character(df_base$Year)
  df_missing <- df_base %>%
    dplyr::filter(n != records.expected) %>%
    dplyr::select(Year, MonthDay, n) %>%
    dplyr::arrange(Year, MonthDay)
  name_table4list <- paste0(param_name, "_DaysMissing")
  ls_excel[[name_table4list]] <- df_missing
}## IF ~ END

param_num <- 6

param_name <- ContData.env$myNames.DataFields[param_num]
param_lab  <- ContData.env$myNames.DataFields.Lab[param_num]

param_boo <- param_name %in% myParameters

# Create Child Chunk if parameter is present
if (param_boo) {
  # Define new environment
  child_env <- new.env()
  child_env$p_num <- param_num
  child_env$p_name <- param_name

  # knit the document and save the character output to an object
  res <- knitr::knit_child(
    "MissingData_01Child.Rmd",
    envir = child_env,
    quiet = TRUE
  )## res ~ END

  # Cat the object to make it render in your main document
  cat(res, sep = '\n')

  #~~~~~~~~~~~~~~~~~
  # Excel
  ## variables
  i <- ContData.env$myNames.DataFields[child_env$p_num]
  i.flag <- paste(ContData.env$myName.Flag, i, sep = ".")
  #
  ## Excel, Flags
  myTable <- addmargins(table(data.import[, i.flag]
                           , useNA = "ifany")
                     , 1)
  df_myTable <- as.data.frame.matrix(t(myTable))
  name_table4list <- paste0(param_name, "_Flags")
  ls_excel[[name_table4list]] <- df_myTable
  #
  ## Excel, Year Month
  myTable <- addmargins(table(data.import[,ContData.env$myName.Yr]
                          ,data.import[,ContData.env$myName.Mo]
                          , useNA = "ifany"))
  df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
  df_myTable <- cbind(rownames(myTable), df_myTable)
  colnames(df_myTable)[1] <- ""
  name_table4list <- paste0(param_name, "_Year_Month")
  ls_excel[[name_table4list]] <- df_myTable
  #
  # Table to Excel, Missing
  df_base <- data.import %>%
    dplyr::filter(!!as.name(i.flag) == "P") %>%
    dplyr::group_by(!!as.name(ContData.env$myName.MoDa)
                    , !!as.name(ContData.env$myName.Yr)) %>%
    dplyr::summarise(n = dplyr::n(), .groups = "drop")
  # munge
  df_base$MonthDay <- sprintf("%04d", df_base$MonthDay)
  # change class
  df_base$MonthDay <- as.character(df_base$MonthDay)
  df_base$Year <- as.character(df_base$Year)
  df_missing <- df_base %>%
    dplyr::filter(n != records.expected) %>%
    dplyr::select(Year, MonthDay, n) %>%
    dplyr::arrange(Year, MonthDay)
  name_table4list <- paste0(param_name, "_DaysMissing")
  ls_excel[[name_table4list]] <- df_missing
}## IF ~ END

param_num <- 7

param_name <- ContData.env$myNames.DataFields[param_num]
param_lab  <- ContData.env$myNames.DataFields.Lab[param_num]

param_boo <- param_name %in% myParameters

# Create Child Chunk if parameter is present
if (param_boo) {
  # Define new environment
  child_env <- new.env()
  child_env$p_num <- param_num
  child_env$p_name <- param_name

  # knit the document and save the character output to an object
  res <- knitr::knit_child(
    "MissingData_01Child.Rmd",
    envir = child_env,
    quiet = TRUE
  )## res ~ END

  # Cat the object to make it render in your main document
  cat(res, sep = '\n')

  #~~~~~~~~~~~~~~~~~
  # Excel
  ## variables
  i <- ContData.env$myNames.DataFields[child_env$p_num]
  i.flag <- paste(ContData.env$myName.Flag, i, sep = ".")
  #
  ## Excel, Flags
  myTable <- addmargins(table(data.import[, i.flag]
                           , useNA = "ifany")
                     , 1)
  df_myTable <- as.data.frame.matrix(t(myTable))
  name_table4list <- paste0(param_name, "_Flags")
  ls_excel[[name_table4list]] <- df_myTable
  #
  ## Excel, Year Month
  myTable <- addmargins(table(data.import[,ContData.env$myName.Yr]
                          ,data.import[,ContData.env$myName.Mo]
                          , useNA = "ifany"))
  df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
  df_myTable <- cbind(rownames(myTable), df_myTable)
  colnames(df_myTable)[1] <- ""
  name_table4list <- paste0(param_name, "_Year_Month")
  ls_excel[[name_table4list]] <- df_myTable
  #
  # Table to Excel, Missing
  df_base <- data.import %>%
    dplyr::filter(!!as.name(i.flag) == "P") %>%
    dplyr::group_by(!!as.name(ContData.env$myName.MoDa)
                    , !!as.name(ContData.env$myName.Yr)) %>%
    dplyr::summarise(n = dplyr::n(), .groups = "drop")
  # munge
  df_base$MonthDay <- sprintf("%04d", df_base$MonthDay)
  # change class
  df_base$MonthDay <- as.character(df_base$MonthDay)
  df_base$Year <- as.character(df_base$Year)
  df_missing <- df_base %>%
    dplyr::filter(n != records.expected) %>%
    dplyr::select(Year, MonthDay, n) %>%
    dplyr::arrange(Year, MonthDay)
  name_table4list <- paste0(param_name, "_DaysMissing")
  ls_excel[[name_table4list]] <- df_missing
}## IF ~ END

param_num <- 8

param_name <- ContData.env$myNames.DataFields[param_num]
param_lab  <- ContData.env$myNames.DataFields.Lab[param_num]

param_boo <- param_name %in% myParameters

# Create Child Chunk if parameter is present
if (param_boo) {
  # Define new environment
  child_env <- new.env()
  child_env$p_num <- param_num
  child_env$p_name <- param_name

  # knit the document and save the character output to an object
  res <- knitr::knit_child(
    "MissingData_01Child.Rmd",
    envir = child_env,
    quiet = TRUE
  )## res ~ END

  # Cat the object to make it render in your main document
  cat(res, sep = '\n')

  #~~~~~~~~~~~~~~~~~
  # Excel
  ## variables
  i <- ContData.env$myNames.DataFields[child_env$p_num]
  i.flag <- paste(ContData.env$myName.Flag, i, sep = ".")
  #
  ## Excel, Flags
  myTable <- addmargins(table(data.import[, i.flag]
                           , useNA = "ifany")
                     , 1)
  df_myTable <- as.data.frame.matrix(t(myTable))
  name_table4list <- paste0(param_name, "_Flags")
  ls_excel[[name_table4list]] <- df_myTable
  #
  ## Excel, Year Month
  myTable <- addmargins(table(data.import[,ContData.env$myName.Yr]
                          ,data.import[,ContData.env$myName.Mo]
                          , useNA = "ifany"))
  df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
  df_myTable <- cbind(rownames(myTable), df_myTable)
  colnames(df_myTable)[1] <- ""
  name_table4list <- paste0(param_name, "_Year_Month")
  ls_excel[[name_table4list]] <- df_myTable
  #
  # Table to Excel, Missing
  df_base <- data.import %>%
    dplyr::filter(!!as.name(i.flag) == "P") %>%
    dplyr::group_by(!!as.name(ContData.env$myName.MoDa)
                    , !!as.name(ContData.env$myName.Yr)) %>%
    dplyr::summarise(n = dplyr::n(), .groups = "drop")
  # munge
  df_base$MonthDay <- sprintf("%04d", df_base$MonthDay)
  # change class
  df_base$MonthDay <- as.character(df_base$MonthDay)
  df_base$Year <- as.character(df_base$Year)
  df_missing <- df_base %>%
    dplyr::filter(n != records.expected) %>%
    dplyr::select(Year, MonthDay, n) %>%
    dplyr::arrange(Year, MonthDay)
  name_table4list <- paste0(param_name, "_DaysMissing")
  ls_excel[[name_table4list]] <- df_missing
}## IF ~ END

param_num <- 9

param_name <- ContData.env$myNames.DataFields[param_num]
param_lab  <- ContData.env$myNames.DataFields.Lab[param_num]

param_boo <- param_name %in% myParameters

# Create Child Chunk if parameter is present
if (param_boo) {
  # Define new environment
  child_env <- new.env()
  child_env$p_num <- param_num
  child_env$p_name <- param_name

  # knit the document and save the character output to an object
  res <- knitr::knit_child(
    "MissingData_01Child.Rmd",
    envir = child_env,
    quiet = TRUE
  )## res ~ END

  # Cat the object to make it render in your main document
  cat(res, sep = '\n')

  #~~~~~~~~~~~~~~~~~
  # Excel
  ## variables
  i <- ContData.env$myNames.DataFields[child_env$p_num]
  i.flag <- paste(ContData.env$myName.Flag, i, sep = ".")
  #
  ## Excel, Flags
  myTable <- addmargins(table(data.import[, i.flag]
                           , useNA = "ifany")
                     , 1)
  df_myTable <- as.data.frame.matrix(t(myTable))
  name_table4list <- paste0(param_name, "_Flags")
  ls_excel[[name_table4list]] <- df_myTable
  #
  ## Excel, Year Month
  myTable <- addmargins(table(data.import[,ContData.env$myName.Yr]
                          ,data.import[,ContData.env$myName.Mo]
                          , useNA = "ifany"))
  df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
  df_myTable <- cbind(rownames(myTable), df_myTable)
  colnames(df_myTable)[1] <- ""
  name_table4list <- paste0(param_name, "_Year_Month")
  ls_excel[[name_table4list]] <- df_myTable
  #
  # Table to Excel, Missing
  df_base <- data.import %>%
    dplyr::filter(!!as.name(i.flag) == "P") %>%
    dplyr::group_by(!!as.name(ContData.env$myName.MoDa)
                    , !!as.name(ContData.env$myName.Yr)) %>%
    dplyr::summarise(n = dplyr::n(), .groups = "drop")
  # munge
  df_base$MonthDay <- sprintf("%04d", df_base$MonthDay)
  # change class
  df_base$MonthDay <- as.character(df_base$MonthDay)
  df_base$Year <- as.character(df_base$Year)
  df_missing <- df_base %>%
    dplyr::filter(n != records.expected) %>%
    dplyr::select(Year, MonthDay, n) %>%
    dplyr::arrange(Year, MonthDay)
  name_table4list <- paste0(param_name, "_DaysMissing")
  ls_excel[[name_table4list]] <- df_missing
}## IF ~ END

param_num <- 10

param_name <- ContData.env$myNames.DataFields[param_num]
param_lab  <- ContData.env$myNames.DataFields.Lab[param_num]

param_boo <- param_name %in% myParameters

# Create Child Chunk if parameter is present
if (param_boo) {
  # Define new environment
  child_env <- new.env()
  child_env$p_num <- param_num
  child_env$p_name <- param_name

  # knit the document and save the character output to an object
  res <- knitr::knit_child(
    "MissingData_01Child.Rmd",
    envir = child_env,
    quiet = TRUE
  )## res ~ END

  # Cat the object to make it render in your main document
  cat(res, sep = '\n')

  #~~~~~~~~~~~~~~~~~
  # Excel
  ## variables
  i <- ContData.env$myNames.DataFields[child_env$p_num]
  i.flag <- paste(ContData.env$myName.Flag, i, sep = ".")
  #
  ## Excel, Flags
  myTable <- addmargins(table(data.import[, i.flag]
                           , useNA = "ifany")
                     , 1)
  df_myTable <- as.data.frame.matrix(t(myTable))
  name_table4list <- paste0(param_name, "_Flags")
  ls_excel[[name_table4list]] <- df_myTable
  #
  ## Excel, Year Month
  myTable <- addmargins(table(data.import[,ContData.env$myName.Yr]
                          ,data.import[,ContData.env$myName.Mo]
                          , useNA = "ifany"))
  df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
  df_myTable <- cbind(rownames(myTable), df_myTable)
  colnames(df_myTable)[1] <- ""
  name_table4list <- paste0(param_name, "_Year_Month")
  ls_excel[[name_table4list]] <- df_myTable
  #
  # Table to Excel, Missing
  df_base <- data.import %>%
    dplyr::filter(!!as.name(i.flag) == "P") %>%
    dplyr::group_by(!!as.name(ContData.env$myName.MoDa)
                    , !!as.name(ContData.env$myName.Yr)) %>%
    dplyr::summarise(n = dplyr::n(), .groups = "drop")
  # munge
  df_base$MonthDay <- sprintf("%04d", df_base$MonthDay)
  # change class
  df_base$MonthDay <- as.character(df_base$MonthDay)
  df_base$Year <- as.character(df_base$Year)
  df_missing <- df_base %>%
    dplyr::filter(n != records.expected) %>%
    dplyr::select(Year, MonthDay, n) %>%
    dplyr::arrange(Year, MonthDay)
  name_table4list <- paste0(param_name, "_DaysMissing")
  ls_excel[[name_table4list]] <- df_missing
}## IF ~ END

param_num <- 11

param_name <- ContData.env$myNames.DataFields[param_num]
param_lab  <- ContData.env$myNames.DataFields.Lab[param_num]

param_boo <- param_name %in% myParameters

# Create Child Chunk if parameter is present
if (param_boo) {
  # Define new environment
  child_env <- new.env()
  child_env$p_num <- param_num
  child_env$p_name <- param_name

  # knit the document and save the character output to an object
  res <- knitr::knit_child(
    "MissingData_01Child.Rmd",
    envir = child_env,
    quiet = TRUE
  )## res ~ END

  # Cat the object to make it render in your main document
  cat(res, sep = '\n')

  #~~~~~~~~~~~~~~~~~
  # Excel
  ## variables
  i <- ContData.env$myNames.DataFields[child_env$p_num]
  i.flag <- paste(ContData.env$myName.Flag, i, sep = ".")
  #
  ## Excel, Flags
  myTable <- addmargins(table(data.import[, i.flag]
                           , useNA = "ifany")
                     , 1)
  df_myTable <- as.data.frame.matrix(t(myTable))
  name_table4list <- paste0(param_name, "_Flags")
  ls_excel[[name_table4list]] <- df_myTable
  #
  ## Excel, Year Month
  myTable <- addmargins(table(data.import[,ContData.env$myName.Yr]
                          ,data.import[,ContData.env$myName.Mo]
                          , useNA = "ifany"))
  df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
  df_myTable <- cbind(rownames(myTable), df_myTable)
  colnames(df_myTable)[1] <- ""
  name_table4list <- paste0(param_name, "_Year_Month")
  ls_excel[[name_table4list]] <- df_myTable
  #
  # Table to Excel, Missing
  df_base <- data.import %>%
    dplyr::filter(!!as.name(i.flag) == "P") %>%
    dplyr::group_by(!!as.name(ContData.env$myName.MoDa)
                    , !!as.name(ContData.env$myName.Yr)) %>%
    dplyr::summarise(n = dplyr::n(), .groups = "drop")
  # munge
  df_base$MonthDay <- sprintf("%04d", df_base$MonthDay)
  # change class
  df_base$MonthDay <- as.character(df_base$MonthDay)
  df_base$Year <- as.character(df_base$Year)
  df_missing <- df_base %>%
    dplyr::filter(n != records.expected) %>%
    dplyr::select(Year, MonthDay, n) %>%
    dplyr::arrange(Year, MonthDay)
  name_table4list <- paste0(param_name, "_DaysMissing")
  ls_excel[[name_table4list]] <- df_missing
}## IF ~ END

param_num <- 12

param_name <- ContData.env$myNames.DataFields[param_num]
param_lab  <- ContData.env$myNames.DataFields.Lab[param_num]

param_boo <- param_name %in% myParameters

# Create Child Chunk if parameter is present
if (param_boo) {
  # Define new environment
  child_env <- new.env()
  child_env$p_num <- param_num
  child_env$p_name <- param_name

  # knit the document and save the character output to an object
  res <- knitr::knit_child(
    "MissingData_01Child.Rmd",
    envir = child_env,
    quiet = TRUE
  )## res ~ END

  # Cat the object to make it render in your main document
  cat(res, sep = '\n')

  #~~~~~~~~~~~~~~~~~
  # Excel
  ## variables
  i <- ContData.env$myNames.DataFields[child_env$p_num]
  i.flag <- paste(ContData.env$myName.Flag, i, sep = ".")
  #
  ## Excel, Flags
  myTable <- addmargins(table(data.import[, i.flag]
                           , useNA = "ifany")
                     , 1)
  df_myTable <- as.data.frame.matrix(t(myTable))
  name_table4list <- paste0(param_name, "_Flags")
  ls_excel[[name_table4list]] <- df_myTable
  #
  ## Excel, Year Month
  myTable <- addmargins(table(data.import[,ContData.env$myName.Yr]
                          ,data.import[,ContData.env$myName.Mo]
                          , useNA = "ifany"))
  df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
  df_myTable <- cbind(rownames(myTable), df_myTable)
  colnames(df_myTable)[1] <- ""
  name_table4list <- paste0(param_name, "_Year_Month")
  ls_excel[[name_table4list]] <- df_myTable
  #
  # Table to Excel, Missing
  df_base <- data.import %>%
    dplyr::filter(!!as.name(i.flag) == "P") %>%
    dplyr::group_by(!!as.name(ContData.env$myName.MoDa)
                    , !!as.name(ContData.env$myName.Yr)) %>%
    dplyr::summarise(n = dplyr::n(), .groups = "drop")
  # munge
  df_base$MonthDay <- sprintf("%04d", df_base$MonthDay)
  # change class
  df_base$MonthDay <- as.character(df_base$MonthDay)
  df_base$Year <- as.character(df_base$Year)
  df_missing <- df_base %>%
    dplyr::filter(n != records.expected) %>%
    dplyr::select(Year, MonthDay, n) %>%
    dplyr::arrange(Year, MonthDay)
  name_table4list <- paste0(param_name, "_DaysMissing")
  ls_excel[[name_table4list]] <- df_missing
}## IF ~ END

param_num <- 13

param_name <- ContData.env$myNames.DataFields[param_num]
param_lab  <- ContData.env$myNames.DataFields.Lab[param_num]

param_boo <- param_name %in% myParameters

# Create Child Chunk if parameter is present
if (param_boo) {
  # Define new environment
  child_env <- new.env()
  child_env$p_num <- param_num
  child_env$p_name <- param_name

  # knit the document and save the character output to an object
  res <- knitr::knit_child(
    "MissingData_01Child.Rmd",
    envir = child_env,
    quiet = TRUE
  )## res ~ END

  # Cat the object to make it render in your main document
  cat(res, sep = '\n')

  #~~~~~~~~~~~~~~~~~
  # Excel
  ## variables
  i <- ContData.env$myNames.DataFields[child_env$p_num]
  i.flag <- paste(ContData.env$myName.Flag, i, sep = ".")
  #
  ## Excel, Flags
  myTable <- addmargins(table(data.import[, i.flag]
                           , useNA = "ifany")
                     , 1)
  df_myTable <- as.data.frame.matrix(t(myTable))
  name_table4list <- paste0(param_name, "_Flags")
  ls_excel[[name_table4list]] <- df_myTable
  #
  ## Excel, Year Month
  myTable <- addmargins(table(data.import[,ContData.env$myName.Yr]
                          ,data.import[,ContData.env$myName.Mo]
                          , useNA = "ifany"))
  df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
  df_myTable <- cbind(rownames(myTable), df_myTable)
  colnames(df_myTable)[1] <- ""
  name_table4list <- paste0(param_name, "_Year_Month")
  ls_excel[[name_table4list]] <- df_myTable
  #
  # Table to Excel, Missing
  df_base <- data.import %>%
    dplyr::filter(!!as.name(i.flag) == "P") %>%
    dplyr::group_by(!!as.name(ContData.env$myName.MoDa)
                    , !!as.name(ContData.env$myName.Yr)) %>%
    dplyr::summarise(n = dplyr::n(), .groups = "drop")
  # munge
  df_base$MonthDay <- sprintf("%04d", df_base$MonthDay)
  # change class
  df_base$MonthDay <- as.character(df_base$MonthDay)
  df_base$Year <- as.character(df_base$Year)
  df_missing <- df_base %>%
    dplyr::filter(n != records.expected) %>%
    dplyr::select(Year, MonthDay, n) %>%
    dplyr::arrange(Year, MonthDay)
  name_table4list <- paste0(param_name, "_DaysMissing")
  ls_excel[[name_table4list]] <- df_missing
}## IF ~ END

param_num <- 14

param_name <- ContData.env$myNames.DataFields[param_num]
param_lab  <- ContData.env$myNames.DataFields.Lab[param_num]

param_boo <- param_name %in% myParameters

# Create Child Chunk if parameter is present
if (param_boo) {
  # Define new environment
  child_env <- new.env()
  child_env$p_num <- param_num
  child_env$p_name <- param_name

  # knit the document and save the character output to an object
  res <- knitr::knit_child(
    "MissingData_01Child.Rmd",
    envir = child_env,
    quiet = TRUE
  )## res ~ END

  # Cat the object to make it render in your main document
  cat(res, sep = '\n')

  #~~~~~~~~~~~~~~~~~
  # Excel
  ## variables
  i <- ContData.env$myNames.DataFields[child_env$p_num]
  i.flag <- paste(ContData.env$myName.Flag, i, sep = ".")
  #
  ## Excel, Flags
  myTable <- addmargins(table(data.import[, i.flag]
                           , useNA = "ifany")
                     , 1)
  df_myTable <- as.data.frame.matrix(t(myTable))
  name_table4list <- paste0(param_name, "_Flags")
  ls_excel[[name_table4list]] <- df_myTable
  #
  ## Excel, Year Month
  myTable <- addmargins(table(data.import[,ContData.env$myName.Yr]
                          ,data.import[,ContData.env$myName.Mo]
                          , useNA = "ifany"))
  df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
  df_myTable <- cbind(rownames(myTable), df_myTable)
  colnames(df_myTable)[1] <- ""
  name_table4list <- paste0(param_name, "_Year_Month")
  ls_excel[[name_table4list]] <- df_myTable
  #
  # Table to Excel, Missing
  df_base <- data.import %>%
    dplyr::filter(!!as.name(i.flag) == "P") %>%
    dplyr::group_by(!!as.name(ContData.env$myName.MoDa)
                    , !!as.name(ContData.env$myName.Yr)) %>%
    dplyr::summarise(n = dplyr::n(), .groups = "drop")
  # munge
  df_base$MonthDay <- sprintf("%04d", df_base$MonthDay)
  # change class
  df_base$MonthDay <- as.character(df_base$MonthDay)
  df_base$Year <- as.character(df_base$Year)
  df_missing <- df_base %>%
    dplyr::filter(n != records.expected) %>%
    dplyr::select(Year, MonthDay, n) %>%
    dplyr::arrange(Year, MonthDay)
  name_table4list <- paste0(param_name, "_DaysMissing")
  ls_excel[[name_table4list]] <- df_missing
}## IF ~ END

param_num <- 15

param_name <- ContData.env$myNames.DataFields[param_num]
param_lab  <- ContData.env$myNames.DataFields.Lab[param_num]

param_boo <- param_name %in% myParameters

# Create Child Chunk if parameter is present
if (param_boo) {
  # Define new environment
  child_env <- new.env()
  child_env$p_num <- param_num
  child_env$p_name <- param_name

  # knit the document and save the character output to an object
  res <- knitr::knit_child(
    "MissingData_01Child.Rmd",
    envir = child_env,
    quiet = TRUE
  )## res ~ END

  # Cat the object to make it render in your main document
  cat(res, sep = '\n')

  #~~~~~~~~~~~~~~~~~
  # Excel
  ## variables
  i <- ContData.env$myNames.DataFields[child_env$p_num]
  i.flag <- paste(ContData.env$myName.Flag, i, sep = ".")
  #
  ## Excel, Flags
  myTable <- addmargins(table(data.import[, i.flag]
                           , useNA = "ifany")
                     , 1)
  df_myTable <- as.data.frame.matrix(t(myTable))
  name_table4list <- paste0(param_name, "_Flags")
  ls_excel[[name_table4list]] <- df_myTable
  #
  ## Excel, Year Month
  myTable <- addmargins(table(data.import[,ContData.env$myName.Yr]
                          ,data.import[,ContData.env$myName.Mo]
                          , useNA = "ifany"))
  df_myTable <- as.data.frame.matrix(myTable, row.names = FALSE)
  df_myTable <- cbind(rownames(myTable), df_myTable)
  colnames(df_myTable)[1] <- ""
  name_table4list <- paste0(param_name, "_Year_Month")
  ls_excel[[name_table4list]] <- df_myTable
  #
  # Table to Excel, Missing
  df_base <- data.import %>%
    dplyr::filter(!!as.name(i.flag) == "P") %>%
    dplyr::group_by(!!as.name(ContData.env$myName.MoDa)
                    , !!as.name(ContData.env$myName.Yr)) %>%
    dplyr::summarise(n = dplyr::n(), .groups = "drop")
  # munge
  df_base$MonthDay <- sprintf("%04d", df_base$MonthDay)
  # change class
  df_base$MonthDay <- as.character(df_base$MonthDay)
  df_base$Year <- as.character(df_base$Year)
  df_missing <- df_base %>%
    dplyr::filter(n != records.expected) %>%
    dplyr::select(Year, MonthDay, n) %>%
    dplyr::arrange(Year, MonthDay)
  name_table4list <- paste0(param_name, "_DaysMissing")
  ls_excel[[name_table4list]] <- df_missing
}## IF ~ END

# Create Excel Output

## FileName
fn_out_xlsx <- paste0(tools::file_path_sans_ext(output_file), ".xlsx")
path_out_xlsx <- file.path(output_dir, fn_out_xlsx)

## Excel, NOTES
nrow_NOTES   <- 6
#NOTES       <- data.frame(matrix(ncol = 3, nrow = nrow_NOTES))
NOTES        <- data.frame(matrix(ncol = 3))
NOTES[, 2]   <- writexl::xl_formula('=""') # set column as formula
NOTES[, 3]   <- writexl::xl_formula('=""') # set column as formula
NOTES[1, 1]  <- "ContDataSumViz, Missing Data"
NOTES[3, 1]  <- "Path and FileName"
NOTES[3, 2]  <- "=LEFT(@CELL(\"filename\",A1),FIND(\"]\",@CELL(\"filename\",A1)))"
NOTES[4, 1]  <- "FileName"
NOTES[4, 2]  <- "=MID(@CELL(\"filename\",B8),FIND(\"[\",@CELL(\"filename\",B8)),
          (FIND(\"]\",@CELL(\"filename\",B8))-FIND(\"[\",@CELL(\"filename\",B8)))+1)"

NOTES[6, 1] <- "Date"
NOTES[6, 2] <- paste0('="', as.character(Sys.Date()), '"')

# Remove Formula
NOTES[1, 2:3] <- NA

#ls_excel <- list()


# Update NOTES
ls_excel[["NOTES"]] <- NOTES

# Save
  writexl::write_xlsx(ls_excel
                     , path = path_out_xlsx
                     , col_names = TRUE
                     , format_headers = TRUE
                     , use_zip64 = FALSE)


leppott/ContDataSumViz documentation built on Jan. 30, 2024, 10 p.m.

R Package Documentation

rdrr.io home R language documentation Run R code online

Browse R Packages

CRAN packages Bioconductor packages R-Forge packages GitHub packages

We want your feedback!

Note that we can't provide technical support on individual packages. You should contact the package authors for that.
GitHub issue tracker
ian@mutexlabs.com
Personal blog

 
Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.

Close