diff --git a/NEWS.md b/NEWS.md
index 04124cd..6b08f7b 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -3,6 +3,7 @@
 * Added ability to set default language in options() (#10) 
 * Added ability to highlight one or more samples in spectra (#15)
 * Added ability to add a background shaded band (like a wide marker) to indicate a given range (#16)
+* Added attributes to imported data to simplify things like y axis units (#17)
 
 # PlotFTIR 1.0.0
 
diff --git a/PlotFTIR.Rproj b/PlotFTIR.Rproj
index 981d703..6433f32 100644
--- a/PlotFTIR.Rproj
+++ b/PlotFTIR.Rproj
@@ -1,4 +1,5 @@
 Version: 1.0
+ProjectId: 20cfe570-0f99-4a3c-b730-e69e15e824cb
 
 RestoreWorkspace: No
 SaveWorkspace: No
@@ -18,7 +19,7 @@ StripTrailingWhitespace: Yes
 BuildType: Package
 PackageUseDevtools: Yes
 PackageInstallArgs: --no-multiarch --with-keep.source
-PackageCheckArgs: --as.cran
+PackageCheckArgs: --as.cran --ignore-vignettes
 PackageRoxygenize: rd,collate,namespace,vignette
 
 ZoteroLibraries: "My Library"
diff --git a/R/io.R b/R/io.R
index 720d1a5..65cd16a 100644
--- a/R/io.R
+++ b/R/io.R
@@ -155,11 +155,23 @@ read_ftir_directory <- function(path, files, sample_names = NA, ...) {
   }
 
   ftir <- data.frame()
+  intensity <- NA
   for (i in seq_along(files)) {
     tryCatch(
       {
-        f <- read_ftir(path, files[i], sample_names[i])
-        ftir <- rbind(ftir, f)
+        f <- read_ftir(path, files[i], sample_names[i], ...)
+        if (is.na(intensity)) {
+          intensity <- attr(f, "intensity")
+        }
+        if (attr(f, "intensity") == intensity) {
+          ftir <- rbind(ftir, f)
+        } else {
+          if (intensity <- "absorbance") {
+            ftir <- rbind(ftir, transmittance_to_absorbance(f))
+          } else {
+            ftir <- rbind(ftir, absorbance_to_transmittance(f))
+          }
+        }
       },
       error = function(e) cli::cli_warn(c("{e}", i = "{.fn PlotFTIR::read_ftir_directory} will try to continue with the next file."))
     )
@@ -206,14 +218,21 @@ read_ftir_csv <- function(path, file, sample_name = NA, ...) {
     }
   }
   if (!("absorbance" %in% colnames(input_file)) && !("transmittance" %in% colnames(input_file))) {
-    if (max(input_file[, colnames(input_file) != "wavenumber"], na.rm = TRUE) > 10) {
-      # must be intensity = transmittance
+    if (intensity_type(input_file) == "transmittance") {
       cli::cli_inform("{.fn PlotFTIR:::read_ftir_csv} has deduced that input data column {.arg {colnames(input_file)[colnames(input_file) != 'wavenumber']}} is {.val transmittance}.")
       colnames(input_file)[colnames(input_file) != "wavenumber"] <- "transmittance"
+      attr(input_file, "intensity") <- "transmittance"
     } else {
       # must be intensity = absorbance
       cli::cli_inform("{.fn PlotFTIR:::read_ftir_csv} has deduced that input data column {.arg {colnames(input_file)[colnames(input_file) != 'wavenumber']}} is {.val absorbance}.")
       colnames(input_file)[colnames(input_file) != "wavenumber"] <- "absorbance"
+      attr(input_file, "intensity") <- "absorbance"
+    }
+  } else {
+    if ("absorbance" %in% colnames(input_file)) {
+      attr(input_file, "intensity") <- "absorbance"
+    } else {
+      attr(input_file, "intensity") <- "transmittance"
     }
   }
 
@@ -243,14 +262,16 @@ read_ftir_asp <- function(path, file, sample_name = NA, ...) {
     "sample_id" = sample_name
   )
 
-  if (max(ftir_data$intensity, na.rm = TRUE) > 10) {
+  if (intensity_type(ftir_data) == "transmittance") {
     # must be intensity = transmittance
     cli::cli_inform("{.fn PlotFTIR:::read_ftir_spc} has deduced that input data is in {.val transmittance} units.")
     colnames(ftir_data)[colnames(ftir_data) == "intensity"] <- "transmittance"
+    attr(input_file, "intensity") <- "transmittance"
   } else {
     # must be intensity = absorbance
     cli::cli_inform("{.fn PlotFTIR:::read_ftir_spc} has deduced that input data is in {.val absorbance} units.")
     colnames(ftir_data)[colnames(ftir_data) == "intensity"] <- "absorbance"
+    attr(input_file, "intensity") <- "absorbance"
   }
 
   return(ftir_data)
@@ -403,16 +424,11 @@ ir_to_df <- function(ir, what) {
   for (s in seq_along(unique(irdata$sample_id))) {
     id <- unique(irdata$sample_id)[s]
     sampleir <- irdata[irdata$sample_id == id, ]
-    if (max(sampleir$y, na.rm = TRUE) < 10) {
-      sample_intensity <- "absorbance"
-      colnames(sampleir)[colnames(sampleir) == "y"] <- "absorbance"
-    } else {
-      sample_intensity <- "transmittance"
-      colnames(sampleir)[colnames(sampleir) == "y"] <- "transmittance"
-    }
-    if (is.na(intensity)) {
-      intensity <- sample_intensity
-    }
+    intensity <- intensity_type(sampleir)
+
+    sample_intensity <- intensity
+    colnames(sampleir)[colnames(sampleir) == "y"] <- intensity
+    attr(sampleir, "intensity") <- intensity
 
     if (intensity == sample_intensity) {
       ftir <- rbind(ftir, sampleir)
@@ -480,7 +496,7 @@ plotftir_to_ir <- function(ftir, metadata = NA) {
   }
 
   # Param Checks
-  ftir <- check_ftir_data(ftir, "PlotFTIR::plotftir_to_ir")
+  ftir <- check_ftir_data(ftir)
   if (!all(is.na(metadata))) {
     if (!is.data.frame(metadata)) {
       cli::cli_abort("Error in {.fn PlotFTIR::plotftir_to_ir}. {.arg metadata} must be either {.code NA} or a {.cls data.frame}.")
@@ -570,7 +586,7 @@ plotftir_to_chemospec <- function(ftir, group_crit = NA, group_colours = "auto",
   }
 
   # Param Checks
-  ftir <- check_ftir_data(ftir, "PlotFTIR::plotftir_to_chemospec")
+  ftir <- check_ftir_data(ftir)
 
   if (nchar(description) > 40) {
     cli::cli_alert_warning("{.pkg ChemoSpec} advises that {.param description} is 40 characters or less. Your description is {nchar(description)} characters.")
@@ -668,8 +684,9 @@ chemospec_to_plotftir <- function(csdata) {
       "intensity" = csdata$data[i, ],
       "sample_id" = csdata$names[i]
     )
-    sample_units <- ifelse(max(df$intensity, na.rm = TRUE) > 10, "transmittance", "absorbance")
+    sample_units <- intensity_type(df)
     colnames(df)[colnames(df) == "intensity"] <- sample_units
+    attr(df, "intensity") <- sample_units
     if (is.na(allunits)) {
       all_units <- sample_units
     }
diff --git a/R/manipulations.R b/R/manipulations.R
index 799976c..3d5af64 100644
--- a/R/manipulations.R
+++ b/R/manipulations.R
@@ -60,7 +60,11 @@ zoom_in_on_range <- function(ftir_spectra_plot, zoom_range = c(1000, 1900)) {
   }
 
   if ("transmittance" %in% colnames(data)) {
-    yrange <- c(0, 100)
+    if('normal' %in% attr(ftir_spectra_plot, 'spectra_style')) {
+      yrange <- c(0,100)
+    } else {
+      yrange <- c(0, max(c(data$transmittance, 100), na.rm = TRUE))
+    }
   } else {
     yrange <- range(data[(data$wavenumber > min(zoom_range) & data$wavenumber < max(zoom_range)), ]$absorbance)
   }
@@ -345,7 +349,6 @@ add_wavenumber_marker <- function(ftir_spectra_plot, wavenumber, text = NULL, li
     cli::cli_abort("Error in {.fn PlotFTIR::add_wavenumber_marker}. {.arg ftir_spectra_plot} must be a ggplot object. You provided {.obj_type_friendly {ftir_spectra_plot}}.")
   }
 
-  # TODO: This should limit on the plot x values.
   data <- ftir_spectra_plot$data
   if (wavenumber < min(data$wavenumber) || wavenumber > max(data$wavenumber)) {
     cli::cli_abort("Error in {.fn PlotFTIR::add_wavenumber_marker}. {.arg wavenumber} must be a value between {round(min(data$wavenumber))} and {round(max(data$wavenumber))} cm^-1.")
diff --git a/R/maths.R b/R/maths.R
index a36b622..9baa602 100644
--- a/R/maths.R
+++ b/R/maths.R
@@ -1,4 +1,4 @@
-## Holds functions to do maths on spectra Currently: average like spectra
+## Holds functions to do maths on spectra
 
 #' Average FTIR Spectra
 #'
@@ -40,8 +40,8 @@
 #' average_spectra(biodiesel, c("biodiesel_5_0", "biodiesel_B5", "diesel_unknown"))
 #' @md
 average_spectra <- function(ftir, sample_ids = NA, average_id = "averaged_spectra") {
-  ftir <- check_ftir_data(ftir, "PlotFTIR::average_spectra")
-
+  ftir <- check_ftir_data(ftir)
+  intensity_attribute <- attr(ftir, "intensity")
 
   if (length(sample_ids) <= 1) {
     if (is.na(sample_ids) || is.null(sample_ids) || length(sample_ids) == 0) {
@@ -73,7 +73,7 @@ average_spectra <- function(ftir, sample_ids = NA, average_id = "averaged_spectr
   other_wavenumbers <- ftir[ftir$sample_id != sample_ids[1], "wavenumber"]
   if (all(first_wavenumbers %in% other_wavenumbers) && all(other_wavenumbers %in% first_wavenumbers)) {
     # make average - when all wavenumbers are present in all samples
-    if ("absorbance" %in% names(ftir)) {
+    if (grepl("absorbance", intensity_attribute)) {
       avg_spectra <- stats::aggregate(absorbance ~ wavenumber, data = ftir, FUN = mean)
     } else {
       avg_spectra <- stats::aggregate(transmittance ~ wavenumber, data = ftir, FUN = mean)
@@ -120,6 +120,8 @@ average_spectra <- function(ftir, sample_ids = NA, average_id = "averaged_spectr
     }
   }
 
+  attr(avg_spectra, "intensity") <- intensity_attribute
+
   return(avg_spectra)
 }
 
@@ -169,7 +171,7 @@ NULL
 #' @rdname add_subtract_scalar
 #' @md
 add_scalar_value <- function(ftir, value, sample_ids = NA) {
-  ftir <- check_ftir_data(ftir, "PlotFTIR::add_scalar_value")
+  ftir <- check_ftir_data(ftir)
 
   if (length(sample_ids) <= 1) {
     if (is.na(sample_ids) || is.null(sample_ids) || length(sample_ids) == 0) {
@@ -202,7 +204,7 @@ add_scalar_value <- function(ftir, value, sample_ids = NA) {
 #' @export
 #' @rdname add_subtract_scalar
 subtract_scalar_value <- function(ftir, value, sample_ids = NA) {
-  ftir <- check_ftir_data(ftir, "PlotFTIR::subtract_scalar_value")
+  ftir <- check_ftir_data(ftir)
 
   if (!is.numeric(value)) {
     cli::cli_abort(c("Error in {.fn PlotFTIR::subtract_scalar_value}. Provided {.arg value} must be numeric.",
@@ -320,8 +322,7 @@ subtract_scalar_value <- function(ftir, value, sample_ids = NA) {
 #' # Adjust the biodiesel spectra to minimum for each sample
 #' recalculate_baseline(biodiesel, method = "minimum", individually = TRUE)
 recalculate_baseline <- function(ftir, sample_ids = NA, wavenumber_range = NA, method = "average", individually = TRUE) {
-  ftir <- check_ftir_data(ftir, "PlotFTIR::recalculate_baseline")
-
+  ftir <- check_ftir_data(ftir)
 
   if (length(sample_ids) <= 1) {
     if (is.na(sample_ids) || is.null(sample_ids) || length(sample_ids) == 0) {
@@ -510,13 +511,14 @@ recalculate_baseline <- function(ftir, sample_ids = NA, wavenumber_range = NA, m
 #' # Normalize just `paper` and `isopropanol` spectra from 4000 to 3100 cm^-1^
 #' normalize_spectra(sample_spectra,
 #'   sample_ids = c("paper", "isopropanol"),
-#'   wavenumber_range = c(4000, 3100))
+#'   wavenumber_range = c(4000, 3100)
+#' )
 normalize_spectra <- function(ftir, sample_ids = NA, wavenumber_range = NA) {
   # Check inputs
-  ftir <- check_ftir_data(ftir, "PlotFTIR::normalize_spectra")
-  if ("transmittance" %in% colnames(ftir)) {
+  ftir <- check_ftir_data(ftir)
+  if ("transmittance" %in% colnames(ftir) || attr(ftir, "intensity") == "transmittance") {
     # Can't normalize transmission spectra
-    cli::cli_abort(c("Error in {.fn PlotFTIR::normalize_spectra}: Normalization of Transmittance spectra not supported.",
+    cli::cli_abort(c("Error in {.fn PlotFTIR::normalize_spectra}: Normalization of transmittance spectra not supported.",
       i = "Convert spectra to absorbance using {.fn transmittance_to_absorbance} then try again."
     ))
   }
@@ -556,5 +558,115 @@ normalize_spectra <- function(ftir, sample_ids = NA, wavenumber_range = NA) {
     ftir[ftir$sample_id == sid, ]$absorbance <- spectra$absorbance
   }
 
+  attr(ftir, "intensity") <- "normalized absorbance"
+
+  return(ftir)
+}
+
+
+#' Convert Between Absorbance and Transmittance
+#'
+#' @description These functions allow for the convenient conversion between
+#'   \%Transmittance and Absorbance units for the Y axis.
+#'
+#'   Converting between \%Transmittance and absorbance units for the Y axis is
+#'   not a simple flipping of axis or inversion. Instead, the two are related by
+#'   the following formulas:
+#'
+#' \deqn{
+#'  A=-log_{10}(\tfrac{\%T}{100})
+#' }
+#'   and
+#' \deqn{
+#'  \%T=10^{-A}\cdot 100
+#' }.
+#'
+#'   Ces fonctions permettent une conversion pratique entre les unités
+#'   \%Transmittance et Absorbance pour l'axe Y. La conversion entre les unités
+#'   \%Transmittance et Absorbance pour l'axe Y n'est pas un simple retournement
+#'   d'axe ou une inversion. Au lieu de cela, les deux sont liés par les
+#'   formules suivantes :
+#'
+#' \deqn{
+#'  A=-log_{10}(\tfrac{\%T}{100})
+#' }
+#'   and
+#' \deqn{
+#'  \%T=10^{-A}\cdot 100
+#' }
+#'
+#' @param ftir A data.frame of FTIR spectral data including column to be
+#'   converted. Can't contain both `absorbance` and `transmittance` column as
+#'   the receiving column would be overwritten
+#'
+#'   Un data.frame de données spectrales IRTF incluant la colonne à convertir.
+#'   Ne peut pas contenir les colonnes `absorbance` et `transmittance` car la
+#'   colonne de réception serait écrasée.
+#'
+#' @return a data.frame of FTIR spectral data with conversion between absorbance
+#'   or transmittance as requested. Note the original data column is removed
+#'   since FTIR spectral data frames can't be fed into plotting functions with
+#'   both transmittance and absorbance data included.
+#'
+#'   un data.frame de données spectrales IRTF avec conversion entre l'absorbance
+#'   ou la transmittance comme demandé. Notez que la colonne de données
+#'   d'origine est supprimée car les trames de données spectrales IRTF ne
+#'   peuvent pas être introduites dans les fonctions de tracé avec les données
+#'   de transmittance et d'absorbance incluses.
+#'
+#' @examples
+#' # Convert from absorbance to transmittance
+#' sample_spectra_transmittance <- absorbance_to_transmittance(sample_spectra)
+#'
+#' # Convert back to absorbance
+#' sample_spectra_absorbance <- transmittance_to_absorbance(sample_spectra_transmittance)
+#'
+#' @name conversion
+NULL
+
+#' @export
+#' @rdname conversion
+absorbance_to_transmittance <- function(ftir) {
+  ftir <- check_ftir_data(ftir)
+  normalized <- grepl("normalized", attr(ftir, "intensity"))
+  if (!("absorbance" %in% colnames(ftir)) || attr(ftir, "intensity") %in% c("transmittance", "normalized transmittance")) {
+    cli::cli_abort("Error in {.fn PlotFTIR::absorbance_to_transmittance}. {.arg ftir} must be absorbance data or contain a {.var absorbance} column.")
+  }
+  ftir$transmittance <- (10^(ftir$absorbance * -1)) * 100
+  ftir$absorbance <- NULL
+
+  # this drops the attributes
+  ftir <- ftir[, c("wavenumber", "transmittance", "sample_id")]
+
+  if (normalized) {
+    attr(ftir, "intensity") <- "normalized transmittance"
+  } else {
+    attr(ftir, "intensity") <- "transmittance"
+  }
+
+  return(ftir)
+}
+
+#' @export
+#' @rdname conversion
+transmittance_to_absorbance <- function(ftir) {
+  ftir <- check_ftir_data(ftir)
+  normalized <- grepl("normalized", attr(ftir, "intensity"))
+
+  if (!("transmittance" %in% colnames(ftir)) || attr(ftir, "intensity") %in% c("absorbance", "normalized absorbance")) {
+    cli::cli_abort("Error in {.fn PlotFTIR::transmittance_to_absorbance}. {.arg ftir} must be transmittance data or contain a {.var transmittance} column.")
+  }
+
+  ftir$absorbance <- -log(ftir$transmittance / 100, base = 10)
+  ftir$transmittance <- NULL
+
+  ftir <- ftir[, c("wavenumber", "absorbance", "sample_id")]
+
+  if (normalized) {
+    attr(ftir, "intensity") <- "normalized absorbance"
+  } else {
+    attr(ftir, "intensity") <- "absorbance"
+  }
+
   return(ftir)
 }
diff --git a/R/plot_ftir.R b/R/plot_ftir.R
index cc935fb..2194b1f 100644
--- a/R/plot_ftir.R
+++ b/R/plot_ftir.R
@@ -86,7 +86,7 @@ plot_ftir_core <- function(ftir, plot_title = "FTIR Spectra", legend_title = "Sa
     ))
   }
 
-  ftir <- check_ftir_data(ftir, "PlotFTIR:::plot_ftir_core")
+  ftir <- check_ftir_data(ftir)
   if (!is.character(plot_title) || length(plot_title) > 2) {
     cli::cli_abort("Error in {.fn PlotFTIR:::plot_ftir_core}. {.arg plot_title} must be a character string or vector of strings with length not more than two.")
   }
@@ -100,10 +100,11 @@ plot_ftir_core <- function(ftir, plot_title = "FTIR Spectra", legend_title = "Sa
   }
 
   # if language is provided, check against permitted, else use default from options
-  if(!is.na(lang)){
+  if (!is.na(lang)) {
     lang <- rlang::arg_match(lang,
-                             values = c("en", "english", "anglais", "fr", "french", "francais", "fran\u00e7ais"),
-                             multiple = FALSE)
+      values = c("en", "english", "anglais", "fr", "french", "francais", "fran\u00e7ais"),
+      multiple = FALSE
+    )
   } else {
     lang <- getOption("PlotFTIR.lang", default = "en")
   }
@@ -118,7 +119,7 @@ plot_ftir_core <- function(ftir, plot_title = "FTIR Spectra", legend_title = "Sa
     }
   }
 
-  mode <- ifelse("absorbance" %in% colnames(ftir), "absorbance", "transmittance")
+  mode <- attr(ftir, "intensity")
 
   if (l == "fr") {
     xtitle <- bquote("Nombre d'onde" ~ (cm^-1))
@@ -126,12 +127,16 @@ plot_ftir_core <- function(ftir, plot_title = "FTIR Spectra", legend_title = "Sa
     xtitle <- bquote("Wavenumber" ~ (cm^-1))
   }
 
-  ytitle <- ifelse(mode == "absorbance", "Absorbance", "% Transmittance")
+  ytitle <- ifelse(mode %in% c("absorbance", "normalized absorbance"), "Absorbance", "% Transmittance")
+
+  if (grepl("normalized", mode)) {
+    ytitle <- paste("Normalized", ytitle)
+  }
 
   ftir <- ftir[stats::complete.cases(ftir), ]
   ftir$wavenumber <- as.numeric(ftir$wavenumber)
 
-  if (mode == "absorbance") {
+  if (grepl("absorbance", mode)) {
     ftir$absorbance <- as.numeric(ftir$absorbance)
     p <- ggplot2::ggplot(ftir) +
       ggplot2::geom_line(ggplot2::aes(x = .data$wavenumber, y = .data$absorbance, color = as.factor(.data$sample_id))) +
@@ -153,7 +158,7 @@ plot_ftir_core <- function(ftir, plot_title = "FTIR Spectra", legend_title = "Sa
     ) +
     ggplot2::guides(color = ggplot2::guide_legend(title = legend_title), x = ggplot2::guide_axis(minor.ticks = TRUE)) +
     ggplot2::theme_light() +
-    ggplot2::scale_x_reverse(breaks = scales::breaks_extended())
+    ggplot2::scale_x_reverse(breaks = scales::breaks_extended(), expand = ggplot2::expansion())
 
   if (!requireNamespace("ggthemes", quietly = TRUE) || length(unique(ftir$sample_id)) > 15) {
     p <- p +
@@ -163,6 +168,14 @@ plot_ftir_core <- function(ftir, plot_title = "FTIR Spectra", legend_title = "Sa
       ggthemes::scale_color_calc()
   }
 
+  if (grepl("normalized", mode)) {
+    p <- p + ggplot2::theme(
+      axis.text.y = ggplot2::element_blank()
+    )
+  }
+
+  attr(p, "intensity") <- attr(ftir, "intensity")
+
   return(p)
 }
 
@@ -200,7 +213,7 @@ plot_ftir_core <- function(ftir, plot_title = "FTIR Spectra", legend_title = "Sa
 #'   plot_ftir_stacked(biodiesel)
 #' }
 plot_ftir_stacked <- function(ftir, plot_title = "FTIR Spectra", legend_title = "Sample ID", stack_offset = 10, lang = NA) {
-  ftir <- check_ftir_data(ftir, "PlotFTIR::plot_ftir_stacked")
+  ftir <- check_ftir_data(ftir)
 
   if (!is.numeric(stack_offset) || length(stack_offset) > 1) {
     cli::cli_abort("Error in {.fn PlotFTIR:::plot_ftir_stacked}. {.arg stack_offset} must be a single numeric value.")
@@ -209,14 +222,14 @@ plot_ftir_stacked <- function(ftir, plot_title = "FTIR Spectra", legend_title =
     cli::cli_abort("Error in {.fn PlotFTIR:::plot_ftir_stacked}. {.arg stack_offset} must be between 0 and 200.")
   }
 
-  mode <- ifelse("absorbance" %in% colnames(ftir), "absorbance", "transmittance")
+  mode <- attr(ftir, "intensity")
 
   # Stack FTIR traces by 10% of range number of unique samples
   stack_samples <- unique(ftir$sample_id)
   nsamples <- length(unique(stack_samples))
 
   if (nsamples > 1) {
-    if (mode == "absorbance") {
+    if (grepl("absorbance", mode)) {
       # Transmittance gets an offset of stack_offset % against a percentage scale
       # for absorbance, most signals max out around 2 so that's the range.
       stack_offset <- (stack_offset / 100) * 2.0
@@ -227,7 +240,7 @@ plot_ftir_stacked <- function(ftir, plot_title = "FTIR Spectra", legend_title =
     )
 
     ftir <- merge(x = ftir, y = offset, by = "sample_id")
-    if (mode == "absorbance") {
+    if (grepl("absorbance", mode)) {
       ftir$absorbance <- ftir$absorbance + ftir$offset
     } else {
       ftir$transmittance <- ftir$transmittance + ftir$offset
@@ -237,9 +250,17 @@ plot_ftir_stacked <- function(ftir, plot_title = "FTIR Spectra", legend_title =
 
   p <- plot_ftir_core(ftir = ftir, plot_title = plot_title, legend_title = legend_title, lang = lang)
 
-  p <- p + ggplot2::theme(
-    axis.text.y = ggplot2::element_blank()
-  )
+  p <- p + ggplot2::theme(axis.text.y = ggplot2::element_blank())
+  suppressMessages(p <- p + ggplot2::coord_cartesian(ylim = c(0, NA)))
+
+  if(grepl("absorbance", mode)){
+    p$labels$y <- "Absorbance (a.u.)"
+  } else {
+    p$labels$y <- "Transmittance (a.u.)"
+  }
+
+
+  attr(p, "spectra_style") <- "stacked"
 
   return(p)
 }
@@ -262,8 +283,10 @@ plot_ftir_stacked <- function(ftir, plot_title = "FTIR Spectra", legend_title =
 #'   plot_ftir(sample_spectra)
 #' }
 plot_ftir <- function(ftir, plot_title = "FTIR Spectra", legend_title = "Sample ID", lang = NA) {
-  ftir <- check_ftir_data(ftir, "PlotFTIR::plot_ftir_stacked")
+  ftir <- check_ftir_data(ftir)
   p <- plot_ftir_core(ftir = ftir, plot_title = plot_title, legend_title = legend_title, lang = lang)
 
+  attr(p, "spectra_style") <- "normal"
+
   return(p)
 }
diff --git a/R/utils.R b/R/utils.R
index 587dd21..9cfdaf0 100644
--- a/R/utils.R
+++ b/R/utils.R
@@ -1,94 +1,3 @@
-#' Convert Between Absorbance and Transmittance
-#'
-#' @description These functions allow for the convenient conversion between
-#'   \%Transmittance and Absorbance units for the Y axis.
-#'
-#'   Converting between \%Transmittance and absorbance units for the Y axis is
-#'   not a simple flipping of axis or inversion. Instead, the two are related by
-#'   the following formulas:
-#'
-#' \deqn{
-#'  A=-log_{10}(\tfrac{\%T}{100})
-#' }
-#'   and
-#' \deqn{
-#'  \%T=10^{-A}\cdot 100
-#' }.
-#'
-#'   Ces fonctions permettent une conversion pratique entre les unités
-#'   \%Transmittance et Absorbance pour l'axe Y. La conversion entre les unités
-#'   \%Transmittance et Absorbance pour l'axe Y n'est pas un simple retournement
-#'   d'axe ou une inversion. Au lieu de cela, les deux sont liés par les
-#'   formules suivantes :
-#'
-#' \deqn{
-#'  A=-log_{10}(\tfrac{\%T}{100})
-#' }
-#'   and
-#' \deqn{
-#'  \%T=10^{-A}\cdot 100
-#' }
-#'
-#' @param ftir A data.frame of FTIR spectral data including column to be
-#'   converted. Can't contain both `absorbance` and `transmittance` column as
-#'   the receiving column would be overwritten
-#'
-#'   Un data.frame de données spectrales IRTF incluant la colonne à convertir.
-#'   Ne peut pas contenir les colonnes `absorbance` et `transmittance` car la
-#'   colonne de réception serait écrasée.
-#'
-#' @return a data.frame of FTIR spectral data with conversion between absorbance
-#'   or transmittance as requested. Note the original data column is removed
-#'   since FTIR spectral data frames can't be fed into plotting functions with
-#'   both transmittance and absorbance data included.
-#'
-#'   un data.frame de données spectrales IRTF avec conversion entre l'absorbance
-#'   ou la transmittance comme demandé. Notez que la colonne de données
-#'   d'origine est supprimée car les trames de données spectrales IRTF ne
-#'   peuvent pas être introduites dans les fonctions de tracé avec les données
-#'   de transmittance et d'absorbance incluses.
-#'
-#' @examples
-#' # Convert from absorbance to transmittance
-#' sample_spectra_transmittance <- absorbance_to_transmittance(sample_spectra)
-#'
-#' # Convert back to absorbance
-#' sample_spectra_absorbance <- transmittance_to_absorbance(sample_spectra_transmittance)
-#'
-#' @name conversion
-NULL
-
-#' @export
-#' @rdname conversion
-absorbance_to_transmittance <- function(ftir) {
-  ftir <- check_ftir_data(ftir, "PlotFTIR::absorbance_to_transmittance")
-  if (!("absorbance" %in% colnames(ftir))) {
-    cli::cli_abort("Error in {.fn PlotFTIR::absorbance_to_transmittance}. {.arg ftir} must contain a {.var absorbance} column.")
-  }
-  ftir$transmittance <- (10^(ftir$absorbance * -1)) * 100
-  ftir$absorbance <- NULL
-
-  ftir <- ftir[, c("wavenumber", "transmittance", "sample_id")]
-
-  return(ftir)
-}
-
-#' @export
-#' @rdname conversion
-transmittance_to_absorbance <- function(ftir) {
-  ftir <- check_ftir_data(ftir, "PlotFTIR::transmittance_to_absorbance")
-  if (!("transmittance" %in% colnames(ftir))) {
-    cli::cli_abort("Error in {.fn PlotFTIR::transmittance_to_absorbance}. {.arg ftir} must contain a {.var transmittance} column.")
-  }
-
-  ftir$absorbance <- -log(ftir$transmittance / 100, base = 10)
-  ftir$transmittance <- NULL
-
-  ftir <- ftir[, c("wavenumber", "absorbance", "sample_id")]
-
-  return(ftir)
-}
-
 #' Get Plot Sample IDs
 #'
 #' @description Get the sample IDs from a prepared plot. Useful if renaming in
@@ -132,17 +41,24 @@ get_plot_sample_ids <- function(ftir_spectra_plot) {
 #' @title Check FTIR Data
 #'
 #' @description Check provided FTIR dataframe is appropriate for manipulation or plotting
-#' Not typically called directly, but as a function in data integrety check process before
-#' further calculation or plotting happens
+#' Not typically called directly, but as a function in data integrity check process before
+#' further calculation or plotting happens. Sets dataframe attribute "intensity" to
+#' "transmittance" or "absorbance" if not previously set.
 #'
 #' @param ftir A data.frame of FTIR spectral data including column to be
 #'  converted. Can't contain both `absorbance` and `transmittance` column.
 #'
-#' @param fn The name of the function, used in printing error codes.
-#'
-#' @return invisible ftir data if ok, typically called for effect of failure.
+#' @return invisible ftir data if ok
 #' @keywords internal
-check_ftir_data <- function(ftir, fn) {
+check_ftir_data <- function(ftir) {
+  fn <- try(deparse(sys.calls()[[sys.nframe() - 1]]), silent = TRUE)
+  if(inherits(fn, 'try-error')) {
+    fn <- "PlotFTIR::check_ftir_data"
+  } else {
+    fn <- paste0("PlotFTIR::", strsplit(fn, "(", fixed = TRUE)[[1]][1])
+  }
+
+
   if ("ir" %in% class(ftir)) {
     cli::cli_inform("Converting {.pkg ir} data to {.pkg PlotFTIR} structure.")
     ftir <- ir_to_plotftir(ftir)
@@ -175,6 +91,36 @@ check_ftir_data <- function(ftir, fn) {
   if (any(!(colnames(ftir) %in% c("sample_id", "wavenumber", "absorbance", "transmittance")))) {
     cli::cli_abort("Error in {.fn {fn}}. {.arg ftir} may only contain columns {.var sample_id}, {.var wavenumber}, and one of {.var absorbance} or {.var transmittance}.")
   }
+  if (!is.null(attr(ftir, "intensity")) && !(attr(ftir, "intensity") %in% c("absorbance", "transmittance", "normalized absorbance", "normalized transmittance"))) {
+    cli::cli_abort("Error in {.fn {fn}}. {.arg ftir} has unexpected attributes.")
+  }
+
+  if (is.null(attr(ftir, "intensity"))) {
+    attr(ftir, "intensity") <- intensity_type(ftir)
+  }
 
   invisible(ftir)
 }
+
+
+#' Intensity Type
+#'
+#' @description Determines if the provided data has intensity type of absorbance or transmittance.
+#'
+#' @inheritParams conversion
+#'
+#' @return a character value 'absorbance' or 'transmittance'
+#' @keywords internal
+intensity_type <- function(ftir) {
+  # Don't check_ftir_data to avoid a loop if called by check_ftir_data()
+
+  if ("absorbance" %in% colnames(ftir)) {
+    return("absorbance")
+  } else if ("transmittance" %in% colnames(ftir)) {
+    return("transmittance")
+  }
+
+  # implied else
+  ftir <- ftir[, -which(names(ftir) %in% c("wavenumber", "sample_id"))]
+  return(ifelse(max(ftir, na.rm = TRUE) > 10, "transmittance", "absorbance"))
+}
diff --git a/R/zzz.R b/R/zzz.R
index c93b06d..1f56621 100644
--- a/R/zzz.R
+++ b/R/zzz.R
@@ -9,7 +9,7 @@
     options("PlotFTIR.lang" = "en")
     packageStartupMessage(
       'Plotting spectra with PlotFTIR. Please cite if plots are used in publishing (`citation("plotFTIR")`).\n',
-      'PlotFTIR set to English as default. Changer au fran\u00e7ais par la fonction options("PlotFTIR.lang" = "en")'
+      'PlotFTIR is set to English as default. Changer au fran\u00e7ais par la fonction `options("PlotFTIR.lang" = "en")`'
     )
   } else {
     if (tolower(lang_option) %in% c("fr", "fra", "french", "francais", "fran\u00e7ais")) {
diff --git a/README.Rmd b/README.Rmd
index 2694622..51c3718 100644
--- a/README.Rmd
+++ b/README.Rmd
@@ -24,6 +24,7 @@ library(PlotFTIR)
 [![R-CMD-check](https://github.com/NRCan/PlotFTIR/actions/workflows/R-CMD-check.yaml/badge.svg)](https://github.com/NRCan/PlotFTIR/actions/workflows/R-CMD-check.yaml)
 [![Lifecycle: stable](https://img.shields.io/badge/lifecycle-stable-brightgreen.svg)](https://lifecycle.r-lib.org/articles/stages.html#stable)
 [![Coveralls test coverage](https://coveralls.io/repos/github/NRCan/PlotFTIR/badge.svg)](https://coveralls.io/github/NRCan/PlotFTIR)
+[![CRAN Downloads](https://cranlogs.r-pkg.org/badges/PlotFTIR)](https://cran.r-project.org/package=PlotFTIR)
 <!-- badges: end -->
 
 ## Introduction and Installation
diff --git a/README.md b/README.md
index dbf4403..68b236b 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,7 @@
 stable](https://img.shields.io/badge/lifecycle-stable-brightgreen.svg)](https://lifecycle.r-lib.org/articles/stages.html#stable)
 [![Coveralls test
 coverage](https://coveralls.io/repos/github/NRCan/PlotFTIR/badge.svg)](https://coveralls.io/github/NRCan/PlotFTIR)
+[![CRAN Downloads](https://cranlogs.r-pkg.org/badges/PlotFTIR)](https://cran.r-project.org/package=PlotFTIR)
 <!-- badges: end -->
 
 ## Introduction and Installation
diff --git a/cran-comments.md b/cran-comments.md
index dd2ca6e..7717208 100644
--- a/cran-comments.md
+++ b/cran-comments.md
@@ -4,3 +4,5 @@
 
 * This is a minor update with improvements
   * Added ability to set default language in options().
+  * Added two functions to enhance graphical output.
+  * Added internal functions to validate data.
diff --git a/man/check_ftir_data.Rd b/man/check_ftir_data.Rd
index 2ca10c0..633eb0d 100644
--- a/man/check_ftir_data.Rd
+++ b/man/check_ftir_data.Rd
@@ -4,20 +4,19 @@
 \alias{check_ftir_data}
 \title{Check FTIR Data}
 \usage{
-check_ftir_data(ftir, fn)
+check_ftir_data(ftir)
 }
 \arguments{
 \item{ftir}{A data.frame of FTIR spectral data including column to be
 converted. Can't contain both `absorbance` and `transmittance` column.}
-
-\item{fn}{The name of the function, used in printing error codes.}
 }
 \value{
-invisible ftir data if ok, typically called for effect of failure.
+invisible ftir data if ok
 }
 \description{
 Check provided FTIR dataframe is appropriate for manipulation or plotting
-Not typically called directly, but as a function in data integrety check process before
-further calculation or plotting happens
+Not typically called directly, but as a function in data integrity check process before
+further calculation or plotting happens. Sets dataframe attribute "intensity" to
+"transmittance" or "absorbance" if not previously set.
 }
 \keyword{internal}
diff --git a/man/conversion.Rd b/man/conversion.Rd
index 0a9a589..99a5d98 100644
--- a/man/conversion.Rd
+++ b/man/conversion.Rd
@@ -1,5 +1,5 @@
 % Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/utils.R
+% Please edit documentation in R/maths.R
 \name{conversion}
 \alias{conversion}
 \alias{absorbance_to_transmittance}
diff --git a/man/intensity_type.Rd b/man/intensity_type.Rd
new file mode 100644
index 0000000..289c2fd
--- /dev/null
+++ b/man/intensity_type.Rd
@@ -0,0 +1,24 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/utils.R
+\name{intensity_type}
+\alias{intensity_type}
+\title{Intensity Type}
+\usage{
+intensity_type(ftir)
+}
+\arguments{
+\item{ftir}{A data.frame of FTIR spectral data including column to be
+  converted. Can't contain both `absorbance` and `transmittance` column as
+  the receiving column would be overwritten
+
+  Un data.frame de données spectrales IRTF incluant la colonne à convertir.
+  Ne peut pas contenir les colonnes `absorbance` et `transmittance` car la
+  colonne de réception serait écrasée.}
+}
+\value{
+a character value 'absorbance' or 'transmittance'
+}
+\description{
+Determines if the provided data has intensity type of absorbance or transmittance.
+}
+\keyword{internal}
diff --git a/man/normalize_spectra.Rd b/man/normalize_spectra.Rd
index e7c2998..6b55c2d 100644
--- a/man/normalize_spectra.Rd
+++ b/man/normalize_spectra.Rd
@@ -57,5 +57,6 @@ normalize_spectra(biodiesel)
 # Normalize just `paper` and `isopropanol` spectra from 4000 to 3100 cm^-1^
 normalize_spectra(sample_spectra,
   sample_ids = c("paper", "isopropanol"),
-  wavenumber_range = c(4000, 3100))
+  wavenumber_range = c(4000, 3100)
+)
 }
diff --git a/tests/testthat/test-manipulations.R b/tests/testthat/test-manipulations.R
index bb8eadc..0324585 100644
--- a/tests/testthat/test-manipulations.R
+++ b/tests/testthat/test-manipulations.R
@@ -65,6 +65,17 @@ test_that("zoom in is ok", {
         ggplot2::ggplot_build(zoomed_transmittance)$layout$panel_params[[1]]$y.range
     )
   )
+
+  # Check that y range hasn't moved for stacked transmittance plots
+  transmittance_stack_plot <- plot_ftir_stacked(absorbance_to_transmittance(biodiesel))
+  zoomed_transmittance_stack <- zoom_in_on_range(transmittance_stack_plot, c(2000, 2600))
+
+  expect_true(
+    all(
+      ggplot2::ggplot_build(transmittance_stack_plot)$layout$panel_params[[1]]$y.range ==
+        ggplot2::ggplot_build(zoomed_transmittance_stack)$layout$panel_params[[1]]$y.range
+    )
+  )
 })
 
 test_that("compress region is ok", {
diff --git a/tests/testthat/test-maths.R b/tests/testthat/test-maths.R
index e3d7925..1fb5da8 100644
--- a/tests/testthat/test-maths.R
+++ b/tests/testthat/test-maths.R
@@ -8,24 +8,24 @@ test_that("average_spectra works - balanced spectra", {
 
   # Average spectra A and B
   average <- average_spectra(ftir_data, sample_ids = c("A", "B"), average_id = "average_AB")
-
   expect_equal(nrow(average), 2) # Expect 2 rows (wavenumbers)
   expect_equal(average$sample_id[1], "average_AB") # Expect new sample ID
   expect_equal(average$absorbance[average$wavenumber == 1000], 0.2) # Expect mean absorbance
+  expect_equal(attr(average, "intensity"), "absorbance")
 
   # Average only sample A
   average <- average_spectra(ftir_data, sample_ids = "A", average_id = "average_A")
-
   expect_equal(nrow(average), 2) # Expect 2 rows (wavenumbers)
   expect_equal(average$sample_id[1], "average_A") # Expect new sample ID
   expect_equal(average$absorbance, ftir_data[ftir_data$sample_id == "A", ]$absorbance) # Expect original data for A
+  expect_equal(attr(average, "intensity"), "absorbance")
 
   # Average all samples
   average <- average_spectra(ftir_data)
-
   expect_equal(nrow(average), 2) # Expect 3 rows (unique wavenumbers)
   expect_equal(average$sample_id[1], "averaged_spectra") # Expect default ID
   expect_equal(average$absorbance[average$wavenumber == 1000], 0.3) # Expect mean absorbance
+  expect_equal(attr(average, "intensity"), "absorbance")
 
   # Test Transmittance
   ftir_transmittance <- ftir_data
@@ -37,13 +37,12 @@ test_that("average_spectra works - balanced spectra", {
   expect_equal(avg_trans$transmittance[avg_trans$wavenumber == 1000], 0.3) # Expect mean absorbance
   expect_equal(average[, c("sample_id", "wavenumber")], avg_trans[, c("sample_id", "wavenumber")])
   expect_equal(average$absorbance, avg_trans$transmittance)
-
+  expect_equal(attr(avg_trans, "intensity"), "transmittance")
   expect_equal(nrow(average), 2) # Expect 3 rows (unique wavenumbers)
   expect_equal(average$sample_id[1], "averaged_spectra") # Expect default ID
   expect_equal(average$absorbance[average$wavenumber == 1000], 0.3) # Expect mean absorbance
 
   expect_error(average_spectra("not_a_data_frame"))
-
   expect_error(average_spectra(ftir_data[, c("wavenumber", "absorbance")]), regexp = "is missing a column", fixed = TRUE)
   expect_error(average_spectra(ftir_data[, c("wavenumber", "sample_id")]), regexp = "must have one of", fixed = TRUE)
   expect_error(average_spectra(ftir_data[, c("sample_id", "absorbance")]), regexp = "is missing a column", fixed = TRUE)
@@ -91,6 +90,11 @@ test_that("average_spectra works unbalanced", {
   expect_equal(mean(avg_13$absorbance), 0.05684917, tolerance = 1e-7)
   expect_equal(mean(avg_23$absorbance), 0.05677168, tolerance = 1e-7)
   expect_equal(mean(avg_123$absorbance), 0.05678947, tolerance = 1e-7)
+
+  expect_equal(attr(avg_12, "intensity"), "absorbance")
+  expect_equal(attr(avg_13, "intensity"), "absorbance")
+  expect_equal(attr(avg_23, "intensity"), "absorbance")
+  expect_equal(attr(avg_123, "intensity"), "absorbance")
 })
 
 test_that("add_subtract_scalar_value works", {
@@ -107,6 +111,7 @@ test_that("add_subtract_scalar_value works", {
   expect_equal(nrow(modified_data), nrow(ftir_data)) # Expect same number of rows
   expect_equal(modified_data$wavenumber, ftir_data$wavenumber) # Expect unchanged wavenumbers
   expect_equal(modified_data$absorbance, c(0.6, 0.7, 0.8, 0.9, 1.0)) # Expect modified absorbance
+  expect_equal(attr(modified_data, "intensity"), "absorbance")
 
   # Add 1.0 to absorbance of samples A and B
   modified_data <- add_scalar_value(ftir_data, value = 1.0, sample_ids = c("A", "B"))
@@ -120,17 +125,21 @@ test_that("add_subtract_scalar_value works", {
 
   expect_error(add_scalar_value(ftir_data, value = 0.5, sample_ids = "invalid_id"), regexp = "All provided `sample_ids` must be in `ftir` data", fixed = TRUE)
 
+  expect_equal(attr(modified_data, "intensity"), "absorbance")
+
   # Modify ftir_data to have transmittance instead of absorbance
   ftir_data_transmittance <- ftir_data
   ftir_data_transmittance$absorbance <- NULL
-  ftir_data_transmittance$transmittance <- c(0.9, 0.8, 0.7, 0.6, 0.5)
+  ftir_data_transmittance$transmittance <- c(90, 80, 70, 60, 50)
 
-  modified_data <- add_scalar_value(ftir_data_transmittance, value = 0.1)
+  modified_data <- add_scalar_value(ftir_data_transmittance, value = 1)
 
-  expect_equal(modified_data$transmittance, c(1.0, 0.9, 0.8, 0.7, 0.6)) # Expect modified transmittance
+  expect_equal(modified_data$transmittance, c(91, 81, 71, 61, 51)) # Expect modified transmittance
+  expect_equal(attr(modified_data, "intensity"), "transmittance")
 
-  modified_data <- subtract_scalar_value(ftir_data_transmittance, value = 0.1)
-  expect_equal(modified_data$transmittance, c(0.8, 0.7, 0.6, 0.5, 0.4))
+  modified_data <- subtract_scalar_value(ftir_data_transmittance, value = 1)
+  expect_equal(modified_data$transmittance, c(89, 79, 69, 59, 49))
+  expect_equal(attr(modified_data, "intensity"), "transmittance")
 })
 
 
@@ -170,45 +179,53 @@ test_that("Baseline - average works", {
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.1, 0, 0.1))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(-0.1, 0, 0.1))
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, method = "average", individually = FALSE))
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.1, 0, 0.1))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0, 0.1, 0.2))
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, method = "average", wavenumber_range = c(1000, 1025), individually = TRUE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.05, 0.05, 0.15))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(-0.05, 0.05, 0.15))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(-0.05, 0.05, 0.15))
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, method = "average", wavenumber_range = c(1000, 1025), individually = FALSE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.05, 0.05, 0.15))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.05, 0.15, 0.25))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.15, 0.25, 0.35))
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "average", individually = TRUE))
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.1, 0.00, 0.1))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.2, 0.3, 0.4))
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "average", individually = FALSE))
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.1, 0.0, 0.1))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.2, 0.3, 0.4))
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "average", individually = TRUE))
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.1, 0.0, 0.1))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(-0.1, 0.0, 0.1))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.3, 0.4, 0.5))
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "average", individually = FALSE))
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.1, 0.0, 0.1))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0, 0.1, 0.2))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.3, 0.4, 0.5))
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   ftir_data$transmittance <- c(100, 90, 80, 90, 80, 70, 80, 70, 60)
   ftir_data$absorbance <- NULL
@@ -220,45 +237,53 @@ test_that("Baseline - average works", {
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(110, 100, 90))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(110, 100, 90))
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, method = "average", individually = FALSE))
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(110, 100, 90))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(100, 90, 80))
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, method = "average", wavenumber_range = c(1000, 1025), individually = TRUE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(105, 95, 85))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(105, 95, 85))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(105, 95, 85))
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, method = "average", wavenumber_range = c(1000, 1025), individually = FALSE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(105, 95, 85))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(95, 85, 75))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(85, 75, 65))
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "average", individually = TRUE))
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(110, 100, 90))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(90, 80, 70))
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "average", individually = FALSE))
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(110, 100, 90))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(90, 80, 70))
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "average", individually = TRUE))
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(110, 100, 90))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(110, 100, 90))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(80, 70, 60))
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "average", individually = FALSE))
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(110, 100, 90))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(100, 90, 80))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(80, 70, 60))
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 })
 
 test_that("Baseline - point works", {
@@ -272,7 +297,7 @@ test_that("Baseline - point works", {
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0, 0.1, 0.2))
-
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   suppressWarnings(expect_warning(recalculate_baseline(ftir_data, method = "point", wavenumber_range = 500, individually = TRUE),
     regexp = "Provided wavenumber is not within spectral range", fixed = TRUE
@@ -286,28 +311,33 @@ test_that("Baseline - point works", {
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.1, 0.2, 0.3))
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "point", wavenumber_range = 1000, individually = TRUE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.2, 0.3, 0.4))
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "point", wavenumber_range = 1000, individually = FALSE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.2, 0.3, 0.4))
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "point", wavenumber_range = 1000, individually = TRUE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0, 0.1, 0.2))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.3, 0.4, 0.5))
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "point", wavenumber_range = 1000, individually = FALSE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.1, 0.2, 0.3))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.3, 0.4, 0.5))
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   ftir_data$transmittance <- c(90, 80, 70, 80, 70, 60, 70, 60, 50)
   ftir_data$absorbance <- NULL
@@ -316,33 +346,39 @@ test_that("Baseline - point works", {
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(100, 90, 80))
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, method = "point", wavenumber_range = 1000, individually = FALSE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(90, 80, 70))
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "point", wavenumber_range = 1000, individually = TRUE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(80, 70, 60))
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "point", wavenumber_range = 1000, individually = FALSE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(80, 70, 60))
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "point", wavenumber_range = 1000, individually = TRUE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(100, 90, 80))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(70, 60, 50))
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "point", wavenumber_range = 1000, individually = FALSE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(90, 80, 70))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(70, 60, 50))
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 })
 
 test_that("Baseline - minimum/maximum works", {
@@ -360,6 +396,7 @@ test_that("Baseline - minimum/maximum works", {
     recalculate_baseline(ftir_data, method = "minimum", individually = TRUE),
     recalculate_baseline(ftir_data, method = "maximum", individually = TRUE)
   )
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, method = "minimum", individually = FALSE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
@@ -369,6 +406,7 @@ test_that("Baseline - minimum/maximum works", {
     recalculate_baseline(ftir_data, method = "minimum", individually = FALSE),
     recalculate_baseline(ftir_data, method = "maximum", individually = FALSE)
   )
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "minimum", individually = TRUE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
@@ -378,6 +416,7 @@ test_that("Baseline - minimum/maximum works", {
     recalculate_baseline(ftir_data, sample_ids = "A", method = "minimum", individually = TRUE),
     recalculate_baseline(ftir_data, sample_ids = "A", method = "maximum", individually = TRUE)
   )
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "minimum", individually = FALSE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
@@ -387,50 +426,51 @@ test_that("Baseline - minimum/maximum works", {
     recalculate_baseline(ftir_data, sample_ids = "A", method = "minimum", individually = FALSE),
     recalculate_baseline(ftir_data, sample_ids = "A", method = "maximum", individually = FALSE)
   )
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", individually = TRUE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0, 0.1, 0.2))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.3, 0.4, 0.5))
-
   expect_equal(
     recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", individually = TRUE),
     recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "maximum", individually = TRUE)
   )
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", individually = FALSE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.1, 0.2, 0.3))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.3, 0.4, 0.5))
-
   expect_equal(
     recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", individually = FALSE),
     recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "maximum", individually = FALSE)
   )
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), wavenumber_range = c(1030, 1050), method = "minimum", individually = TRUE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.2, -0.1, 0.0))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(-0.2, -0.1, 0.0))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.3, 0.4, 0.5))
-
   expect_equal(
     recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", wavenumber_range = c(1030, 1050), individually = TRUE),
     recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "maximum", wavenumber_range = c(1030, 1050), individually = TRUE)
   )
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), wavenumber_range = c(1030, 1050), method = "minimum", individually = FALSE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.2, -0.1, 0.0))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(-0.1, 0.0, 0.1))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.3, 0.4, 0.5))
-
   expect_equal(
     recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", wavenumber_range = c(1030, 1050), individually = FALSE),
     recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "maximum", wavenumber_range = c(1030, 1050), individually = FALSE)
   )
+  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")
 
   ftir_data$transmittance <- c(90, 80, 70, 80, 70, 60, 70, 60, 50)
   ftir_data$absorbance <- NULL
@@ -443,6 +483,7 @@ test_that("Baseline - minimum/maximum works", {
     recalculate_baseline(ftir_data, method = "minimum", individually = TRUE),
     recalculate_baseline(ftir_data, method = "maximum", individually = TRUE)
   )
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, method = "minimum", individually = FALSE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
@@ -452,6 +493,7 @@ test_that("Baseline - minimum/maximum works", {
     recalculate_baseline(ftir_data, method = "minimum", individually = FALSE),
     recalculate_baseline(ftir_data, method = "maximum", individually = FALSE)
   )
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "minimum", individually = TRUE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
@@ -461,6 +503,7 @@ test_that("Baseline - minimum/maximum works", {
     recalculate_baseline(ftir_data, sample_ids = "A", method = "minimum", individually = TRUE),
     recalculate_baseline(ftir_data, sample_ids = "A", method = "maximum", individually = TRUE)
   )
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "minimum", individually = FALSE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
@@ -470,50 +513,51 @@ test_that("Baseline - minimum/maximum works", {
     recalculate_baseline(ftir_data, sample_ids = "A", method = "minimum", individually = FALSE),
     recalculate_baseline(ftir_data, sample_ids = "A", method = "maximum", individually = FALSE)
   )
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", individually = TRUE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(100, 90, 80))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(70, 60, 50))
-
   expect_equal(
     recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", individually = TRUE),
     recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "maximum", individually = TRUE)
   )
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", individually = FALSE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(90, 80, 70))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(70, 60, 50))
-
   expect_equal(
     recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", individually = FALSE),
     recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "maximum", individually = FALSE)
   )
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), wavenumber_range = c(1030, 1050), method = "minimum", individually = TRUE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(120, 110, 100))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(120, 110, 100))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(70, 60, 50))
-
   expect_equal(
     recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", wavenumber_range = c(1030, 1050), individually = TRUE),
     recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "maximum", wavenumber_range = c(1030, 1050), individually = TRUE)
   )
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 
   recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), wavenumber_range = c(1030, 1050), method = "minimum", individually = FALSE)
   expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(120, 110, 100))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(110, 100, 90))
   expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(70, 60, 50))
-
   expect_equal(
     recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", wavenumber_range = c(1030, 1050), individually = FALSE),
     recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "maximum", wavenumber_range = c(1030, 1050), individually = FALSE)
   )
+  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
 })
 
 
@@ -524,7 +568,7 @@ test_that("Normalization works", {
   expect_error(normalize_spectra(biodiesel, wavenumber_range = c("one", "two")), regexp = "`wavenumber_range` must be `numeric` or `NA`.", fixed = TRUE)
   expect_error(normalize_spectra(biodiesel, wavenumber_range = c(1, NA)), regexp = "`wavenumber_range` must be `numeric` or `NA`", fixed = TRUE)
   expect_error(normalize_spectra(biodiesel, wavenumber_range = 1500), regexp = "must be of length 2", fixed = TRUE)
-  expect_error(normalize_spectra(absorbance_to_transmittance(biodiesel)), regexp = "Normalization of Transmittance spectra not supported", fixed = TRUE)
+  expect_error(normalize_spectra(absorbance_to_transmittance(biodiesel)), regexp = "Normalization of transmittance spectra not supported", fixed = TRUE)
 
   spectra <- data.frame(
     wavenumber = c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10),
@@ -543,4 +587,87 @@ test_that("Normalization works", {
     range(biodiesel_normal[biodiesel_normal$sample_id == "biodiesel_0", "absorbance"])
   )
   expect_equal(range(biodiesel_normal[biodiesel_normal$sample_id == "diesel_unknown", "absorbance"]), c(0, 1))
+  expect_equal(attr(biodiesel_normal, "intensity"), "normalized absorbance")
+})
+
+
+test_that("conversion between units works", {
+  biodiesel_transmittance <- absorbance_to_transmittance(biodiesel)
+  biodiesel_absorbance <- transmittance_to_absorbance(biodiesel_transmittance)
+  expect_named(
+    biodiesel_transmittance,
+    c("wavenumber", "transmittance", "sample_id")
+  )
+  expect_named(
+    transmittance_to_absorbance(biodiesel_transmittance),
+    c("wavenumber", "absorbance", "sample_id")
+  )
+
+  expect_equal(attr(biodiesel_transmittance, "intensity"), "transmittance")
+  expect_equal(attr(biodiesel_absorbance, "intensity"), "absorbance")
+
+  biodiesel_normal <- normalize_spectra(biodiesel)
+  biodiesel_normal_trans <- absorbance_to_transmittance(biodiesel_normal)
+  expect_equal(attr(biodiesel_normal_trans, "intensity"), "normalized transmittance")
+  expect_equal(attr(transmittance_to_absorbance(biodiesel_normal_trans), "intensity"), "normalized absorbance")
+
+  expect_error(transmittance_to_absorbance(biodiesel),
+    "`ftir` must be transmittance data or contain a `transmittance` column.",
+    fixed = TRUE
+  )
+  expect_error(absorbance_to_transmittance(absorbance_to_transmittance(biodiesel)),
+    "`ftir` must be absorbance data or contain a `absorbance` column.",
+    fixed = TRUE
+  )
+
+  example_data <- data.frame(
+    "wavenumber" = 1L,
+    "absorbance" = c(0, .5, 1, 1.5, 2),
+    "sample_id" = "test"
+  )
+  expect_equal(absorbance_to_transmittance(example_data)$transmittance,
+    c(100, 31.62278, 10, 3.162278, 1),
+    tolerance = 1e-4
+  )
+
+  example_data2 <- data.frame(
+    "wavenumber" = 1L,
+    "transmittance" = c(100, 50, 10, 5, 1),
+    "sample_id" = "test"
+  )
+  expect_equal(transmittance_to_absorbance(example_data2)$absorbance,
+    c(0, 0.30103, 1, 1.30103, 2),
+    tolerance = 1e-4
+  )
+
+  example_data3 <- data.frame(
+    "wavenumber" = 1L,
+    "absorbance" = c(0, 0.5, 1, 1.5, 2),
+    "sample_id" = "test",
+    "transmittance" = c(100, 50, 10, 5, 1)
+  )
+  expect_error(absorbance_to_transmittance(example_data3),
+    "`ftir` cannot contain both `absorbance` and `transmittance` columns.",
+    fixed = TRUE
+  )
+  expect_error(transmittance_to_absorbance(example_data3),
+    "`ftir` cannot contain both `absorbance` and `transmittance` columns.",
+    fixed = TRUE
+  )
+})
+
+test_that("Normalization carries thorugh other functions", {
+  biodiesel_normal <- normalize_spectra(biodiesel, sample_ids = c("diesel_unknown"))
+
+  expect_equal(
+    range(biodiesel[biodiesel$sample_id == "biodiesel_0", "absorbance"]),
+    range(biodiesel_normal[biodiesel_normal$sample_id == "biodiesel_0", "absorbance"])
+  )
+  expect_equal(range(biodiesel_normal[biodiesel_normal$sample_id == "diesel_unknown", "absorbance"]), c(0, 1))
+  expect_equal(attr(biodiesel_normal, "intensity"), "normalized absorbance")
+
+  expect_equal(attr(add_scalar_value(biodiesel_normal, 1), "intensity"), "normalized absorbance")
+  expect_equal(attr(recalculate_baseline(biodiesel_normal, method = "point", wavenumber_range = 3900), "intensity"), "normalized absorbance")
+
+  expect_equal(attr(absorbance_to_transmittance(biodiesel_normal), "intensity"), "normalized transmittance")
 })
diff --git a/tests/testthat/test-plot_ftir.R b/tests/testthat/test-plot_ftir.R
index 973692b..b075139 100644
--- a/tests/testthat/test-plot_ftir.R
+++ b/tests/testthat/test-plot_ftir.R
@@ -13,21 +13,23 @@ test_that("Plots are generated", {
   p1 <- plot_ftir(biodiesel)
   p2 <- plot_ftir_stacked(biodiesel)
 
-  biodiesel_transmittance <- absorbance_to_transmittance(biodiesel)
-
-  p3 <- plot_ftir(biodiesel_transmittance)
-  p4 <- plot_ftir_stacked(biodiesel_transmittance)
+  p3 <- plot_ftir(absorbance_to_transmittance(biodiesel))
+  p4 <- plot_ftir_stacked(absorbance_to_transmittance(biodiesel))
+  p5 <- plot_ftir(normalize_spectra(biodiesel))
 
   expect_true(ggplot2::is.ggplot(p1))
   expect_true(ggplot2::is.ggplot(p2))
   expect_equal(p1$labels$y, "Absorbance")
+  expect_equal(p2$labels$y, "Absorbance (a.u.)")
   expect_true(ggplot2::is.ggplot(p3))
   expect_true(ggplot2::is.ggplot(p4))
   expect_equal(p3$label$y, "% Transmittance")
+  expect_equal(p4$label$y, "Transmittance (a.u.)")
+  expect_equal(p5$label$y, "Normalized Absorbance")
 
   # ensure lots of samples can be plotted with rollover to viridis palette.
-  p5 <- suppressWarnings(plot_ftir(rbind(biodiesel, sample_spectra)))
-  expect_true(ggplot2::is.ggplot(p5))
+  p6 <- suppressWarnings(plot_ftir(rbind(biodiesel, sample_spectra)))
+  expect_true(ggplot2::is.ggplot(p6))
   expect_equal(p1$labels$y, "Absorbance")
 })
 
@@ -52,7 +54,7 @@ test_that("data is checked correctly", {
     fixed = TRUE
   )
   expect_error(plot_ftir(ftir = full_data_df[, c("sample_id", "wavenumber")]),
-    "`ftir` must have one of `absorbance` or `transmittance` columns.",
+    "Error in `PlotFTIR::plot_ftir()`. `ftir` must have one of `absorbance` or `transmittance` columns.",
     fixed = TRUE
   )
   expect_error(plot_ftir(ftir = full_data_df),
diff --git a/tests/testthat/test-utils.R b/tests/testthat/test-utils.R
index 49b6620..22c9e9f 100644
--- a/tests/testthat/test-utils.R
+++ b/tests/testthat/test-utils.R
@@ -1,59 +1,3 @@
-test_that("conversion between units works", {
-  biodiesel_transmittance <- absorbance_to_transmittance(biodiesel)
-  expect_named(
-    biodiesel_transmittance,
-    c("wavenumber", "transmittance", "sample_id")
-  )
-  expect_named(
-    transmittance_to_absorbance(biodiesel_transmittance),
-    c("wavenumber", "absorbance", "sample_id")
-  )
-
-  expect_error(transmittance_to_absorbance(biodiesel),
-    "`ftir` must contain a `transmittance` column.",
-    fixed = TRUE
-  )
-  expect_error(absorbance_to_transmittance(absorbance_to_transmittance(biodiesel)),
-    "`ftir` must contain a `absorbance` column.",
-    fixed = TRUE
-  )
-
-  example_data <- data.frame(
-    "wavenumber" = 1L,
-    "absorbance" = c(0, .5, 1, 1.5, 2),
-    "sample_id" = "test"
-  )
-  expect_equal(absorbance_to_transmittance(example_data)$transmittance,
-    c(100, 31.62278, 10, 3.162278, 1),
-    tolerance = 1e-4
-  )
-
-  example_data2 <- data.frame(
-    "wavenumber" = 1L,
-    "transmittance" = c(100, 50, 10, 5, 1),
-    "sample_id" = "test"
-  )
-  expect_equal(transmittance_to_absorbance(example_data2)$absorbance,
-    c(0, 0.30103, 1, 1.30103, 2),
-    tolerance = 1e-4
-  )
-
-  example_data3 <- data.frame(
-    "wavenumber" = 1L,
-    "absorbance" = c(0, 0.5, 1, 1.5, 2),
-    "sample_id" = "test",
-    "transmittance" = c(100, 50, 10, 5, 1)
-  )
-  expect_error(absorbance_to_transmittance(example_data3),
-    "`ftir` cannot contain both `absorbance` and `transmittance` columns.",
-    fixed = TRUE
-  )
-  expect_error(transmittance_to_absorbance(example_data3),
-    "`ftir` cannot contain both `absorbance` and `transmittance` columns.",
-    fixed = TRUE
-  )
-})
-
 test_that("Plot SampleID extraction is ok", {
   # Test for ggplot2 else skip
   if (!require("ggplot2", quietly = TRUE)) {
@@ -78,3 +22,24 @@ test_that("Plot SampleID extraction is ok", {
     fixed = TRUE
   )
 })
+
+test_that("Intensity Typing works", {
+  expect_equal(intensity_type(biodiesel), "absorbance")
+  expect_equal(intensity_type(absorbance_to_transmittance(biodiesel)), "transmittance")
+  b2 <- biodiesel
+  colnames(biodiesel)[colnames(biodiesel) == "absorbance"] <- "intensity"
+  expect_equal(intensity_type(b2), "absorbance")
+})
+
+test_that("Checking FTIR data works", {
+  # Most checks are validated in one way or another by the repeated calling of the check_ftir_data()
+  # function in the other code, but we intentionally manually validate here.
+
+  bad_ftir <- biodiesel
+  attr(bad_ftir, "intensity") <- "test"
+  expect_error(check_ftir_data(bad_ftir), "has unexpected attributes.", fixed = TRUE)
+
+  no_attr_ftir <- biodiesel
+  attr(no_attr_ftir, "intensity") <- NULL
+  expect_equal(attr(check_ftir_data(no_attr_ftir), "intensity"), "absorbance")
+})