diff --git a/R/generateSettings.R b/R/generateSettings.R
index c10a4c70..ac5530d1 100644
--- a/R/generateSettings.R
+++ b/R/generateSettings.R
@@ -7,15 +7,16 @@
 #' @param standard The data standard for which to create settings. Valid options are "SDTM", "AdAM" or "None". Default: \code{"SDTM"}
 #' @param chart The chart for which standards should be generated ("eDish" only for now) . Default: \code{"eDish"}.
 #' @param partial Boolean for whether or not the standard is a partial standard. Default: \code{FALSE}.
-#' @param partial_cols Optional character vector of the matched cols if partial is TRUE. It will not be used if partial is FALSE Default: \code{NULL}.
+#' @param partial_keys Optional character vector of the matched settings if partial is TRUE. Settings should be identified using the text_key format described in ?settingsMetadata. Setting is ignored when partial is FALSE. Default: \code{NULL}.
 #' @return A list containing the appropriate settings for the selected chart
 #' 
 #' @examples 
 #' 
 #' generateSettings(standard="SDTM") 
 #' generateSettings(standard="SdTm") #also ok
-#' generateSettings(standard="SDTM", partial=TRUE, partial_cols = c("USUBJID","TEST","STRESN"))
 #' generateSettings(standard="ADaM")
+#' pkeys<- c("id_col","measure_col","value_col")
+#' generateSettings(standard="adam", partial=TRUE, partial_keys=pkeys)
 #' 
 #' generateSettings(standard="a different standard") 
 #' #returns shell settings list with no data mapping
@@ -30,26 +31,40 @@
 #' 
 #' @export
 
-generateSettings <- function(standard="None", chart="eDish", partial=FALSE, partial_cols=NULL){
+generateSettings <- function(standard="None", chart="eDish", partial=FALSE, partial_keys=NULL){
   if(tolower(chart)!="edish"){
     stop(paste0("Can't generate settings for the specified chart ('",chart,"'). Only the 'eDish' chart is supported for now."))
   }
   
-  # Check that partial_cols is supplied if partial is true
-  if  (is.null(partial_cols) & partial ) {
-    stop("partial_cols must be supplied if the standard is partial")
+  # Check that partial_keys is supplied if partial is true
+  if  (is.null(partial_keys) & partial ) {
+    stop("partial_keys must be supplied if the standard is partial")
   }
   
-  metadata <- safetyGraphics::getSettingsMetadata(
-    charts = chart, 
-    cols=c("text_key","adam","sdtm"),
-    filter_expr = .data$adam != '' & .data$sdtm != '' 
-  )
-
-  # Split on -- for multi-level handling 
-  hierarchical_metadata <- str_split(metadata$text_key, "--") 
+  # Coerce options to lowercase
+  standard<-tolower(standard)
+  chart<-tolower(chart)
+  
+  # Build a table of data mappings for the selected standard and partial settings
+  standardList<-c("adam","sdtm") #TODO: automatically generate this from metadata
+  if(standard %in% standardList){
+    dataMappings <- safetyGraphics::getSettingsMetadata(
+      charts = chart, 
+      cols=c("text_key",standard,"setting_required")
+    ) %>% 
+    filter(.data$setting_required)%>%
+    rename("column_name" = standard)%>%
+    filter(.data$column_name != '')
+    
+    if(partial){
+      dataMappings<-dataMappings%>%filter(.data$text_key %in% partial_keys) 
+    }
+  }
   
-  settings<-list(
+  # build shell settings for each chart 
+  # TODO: move these to `/data` eventually
+  shells<-list()
+  shells[["edish"]]<-list(
     id_col = NULL,
     value_col = NULL,
     measure_col = NULL,
@@ -69,7 +84,7 @@ generateSettings <- function(standard="None", chart="eDish", partial=FALSE, part
     analysisFlag = list(value_col=NULL,
                         values=list()),
     
-    x_options = c("LT", "AST", "ALP"),
+    x_options = c("ALT", "AST", "ALP"),
     y_options = c("TB", "ALP"),
     visit_window = 30,
     r_ratio_filter = TRUE,
@@ -78,42 +93,12 @@ generateSettings <- function(standard="None", chart="eDish", partial=FALSE, part
     warningText = "Caution: This interactive graphic is not validated. Any clinical recommendations based on this tool should be confirmed using your organizations standard operating procedures."
   )
   
-  potential_settings <- settings
-  
-  standard_low <- tolower(standard)
-  
-  if (standard_low == "adam" | standard_low == "sdtm") {
-    
-  for (row in hierarchical_metadata)  {
-    if (length(row) == 1) {
-      potential_settings[row] <- filter(metadata,.data$text_key == !!row)[[standard_low]]
-    } else if (length(row) == 2) {
-      potential_settings[row[[1]]][[1]][row[[2]]] <- filter(metadata, grepl(!!row[[2]],.data$text_key))[[standard_low]]
-    } else{
-      stop("Three level setting nests are not currently supported")
-    }
-    
-  }
-  
-  }
-  
-  if(partial) {
-    
-    settings_names <- names(settings)
-    
-    potential_names <- names(potential_settings)
-    
-    for(i in 1:length(settings)) {
-      if (potential_settings[i] %in% partial_cols) {
-        settings[[which(settings_names == potential_names[i])]] <- potential_settings[[i]]
-      }
-    }
-    
-  } else {
-    
-    settings <- potential_settings
-    
+  # loop through dataMappings and apply them to the shell
+  if(standard %in% standardList){
+    for(row in 1:nrow(dataMappings)){
+      shells[[chart]]<-setSettingsValue(settings = shells[[chart]], key = textKeysToList(dataMappings[row,"text_key"])[[1]], value = dataMappings[row, "column_name"])
+    }    
   }
-  
-  return(settings)
+
+  return(shells[[chart]])
 }
\ No newline at end of file
diff --git a/R/setSettingsValue.R b/R/setSettingsValue.R
new file mode 100644
index 00000000..8052d237
--- /dev/null
+++ b/R/setSettingsValue.R
@@ -0,0 +1,37 @@
+#' Set the value for a given named parameter
+#'
+#' Sets the value for a named parameter (\code{key}) to given \code{value} in a list (\code{settings})
+#'
+#' @param key a list (like those provided by \code{getSettingKeys()}) defining the position of parameter in the settings object. 
+#' @param value the value to set
+#' @param settings The settings list used to generate a chart like \code{eDISH()}
+#' @return the updated settings object
+#' 
+#' @examples 
+#' testSet<-list(a=list(b="myValue"))
+#' safetyGraphics:::setSettingsValue(key=list("a","b"), value="notMyValue", settings=testSet) 
+#' #returns list(a=list(b="notMyValue")))
+#' 
+#' adamSettings<-generateSettings(standard="AdAM")
+#' safetyGraphics:::setSettingsValue(list("id_col"),"customID",adamSettings) 
+#' safetyGraphics:::setSettingsValue(list("measure_values","ALP"),"Alanine Aminotrans",adamSettings)
+#' safetyGraphics:::setSettingsValue(list("myCustomSetting"),"customized",adamSettings) 
+#' #adds myCustomSetting to adamSettings
+#' 
+#' @keywords internal
+
+
+setSettingsValue <- function(key, value, settings){
+  stopifnot(
+    typeof(settings)=="list"
+  )
+  
+  firstKey <- key[[1]]
+  if(length(key)==1){
+    settings[[firstKey]]<-value
+    return(settings)
+  }else{
+    settings[[firstKey]]<-setSettingsValue(settings = settings[[firstKey]],key = key[2:length(key)], value)
+    return(settings)
+  }
+}
\ No newline at end of file
diff --git a/man/detectStandard.Rd b/man/detectStandard.Rd
index 2d95265e..8536045e 100644
--- a/man/detectStandard.Rd
+++ b/man/detectStandard.Rd
@@ -23,7 +23,6 @@ This function attempts to detect the data CDISC clinical standard used in a give
 This function compares the columns in the provided \code{"data"} with the required columns for a given data standard/domain combination. The function is designed to work with the SDTM and AdAM CDISC(<https://www.cdisc.org/>) standards for clinical trial data. Currently, "labs" is the only domain supported.
 }
 \examples{
-
 detectStandard(adlbc)[["standard"]] #AdAM
 detectStandard(iris)[["standard"]] #none
 
diff --git a/man/generateSettings.Rd b/man/generateSettings.Rd
index 60223b46..f4bb5e9c 100644
--- a/man/generateSettings.Rd
+++ b/man/generateSettings.Rd
@@ -5,7 +5,7 @@
 \title{Generate a settings object based on a data standard}
 \usage{
 generateSettings(standard = "None", chart = "eDish", partial = FALSE,
-  partial_cols = NULL)
+  partial_keys = NULL)
 }
 \arguments{
 \item{standard}{The data standard for which to create settings. Valid options are "SDTM", "AdAM" or "None". Default: \code{"SDTM"}}
@@ -14,7 +14,7 @@ generateSettings(standard = "None", chart = "eDish", partial = FALSE,
 
 \item{partial}{Boolean for whether or not the standard is a partial standard. Default: \code{FALSE}.}
 
-\item{partial_cols}{Optional character vector of the matched cols if partial is TRUE. It will not be used if partial is FALSE Default: \code{NULL}.}
+\item{partial_keys}{Optional character vector of the matched settings if partial is TRUE. Settings should be identified using the text_key format described in ?settingsMetadata. Setting is ignored when partial is FALSE. Default: \code{NULL}.}
 }
 \value{
 A list containing the appropriate settings for the selected chart
@@ -29,8 +29,9 @@ The function is designed to work with the SDTM and AdAM CDISC(<https://www.cdisc
 
 generateSettings(standard="SDTM") 
 generateSettings(standard="SdTm") #also ok
-generateSettings(standard="SDTM", partial=TRUE, partial_cols = c("USUBJID","TEST","STRESN"))
 generateSettings(standard="ADaM")
+pkeys<- c("id_col","measure_col","value_col")
+generateSettings(standard="adam", partial=TRUE, partial_keys=pkeys)
 
 generateSettings(standard="a different standard") 
 #returns shell settings list with no data mapping
diff --git a/man/setSettingsValue.Rd b/man/setSettingsValue.Rd
new file mode 100644
index 00000000..250bc4c4
--- /dev/null
+++ b/man/setSettingsValue.Rd
@@ -0,0 +1,34 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/setSettingsValue.R
+\name{setSettingsValue}
+\alias{setSettingsValue}
+\title{Set the value for a given named parameter}
+\usage{
+setSettingsValue(key, value, settings)
+}
+\arguments{
+\item{key}{a list (like those provided by \code{getSettingKeys()}) defining the position of parameter in the settings object.}
+
+\item{value}{the value to set}
+
+\item{settings}{The settings list used to generate a chart like \code{eDISH()}}
+}
+\value{
+the updated settings object
+}
+\description{
+Sets the value for a named parameter (\code{key}) to given \code{value} in a list (\code{settings})
+}
+\examples{
+testSet<-list(a=list(b="myValue"))
+safetyGraphics:::setSettingsValue(key=list("a","b"), value="notMyValue", settings=testSet) 
+#returns list(a=list(b="notMyValue")))
+
+adamSettings<-generateSettings(standard="AdAM")
+safetyGraphics:::setSettingsValue(list("id_col"),"customID",adamSettings) 
+safetyGraphics:::setSettingsValue(list("measure_values","ALP"),"Alanine Aminotrans",adamSettings)
+safetyGraphics:::setSettingsValue(list("myCustomSetting"),"customized",adamSettings) 
+#adds myCustomSetting to adamSettings
+
+}
+\keyword{internal}
diff --git a/tests/testthat/test_generateSettings.R b/tests/testthat/test_generateSettings.R
index 5ebf128d..78dbc96b 100644
--- a/tests/testthat/test_generateSettings.R
+++ b/tests/testthat/test_generateSettings.R
@@ -26,51 +26,64 @@ test_that("a warning is thrown if chart isn't eDish",{
 })
 
 test_that("data mappings are null when setting=none, character otherwise",{
-  column_setting_names<-c("id_col", "value_col", "measure_col", "normal_col_low", "normal_col_high", "studyday_col", "visit_col", "visitn_col")
+  data_setting_keys<-c("id_col", "value_col", "measure_col", "normal_col_low", "normal_col_high", "studyday_col","measure_values--ALT","measure_values--ALP","measure_values--TB","measure_values--AST")
   none_settings <- generateSettings(standard="None")
-  for(name in column_setting_names){
-    expect_null(none_settings[[name]])
+  for(text_key in data_setting_keys){
+    key<-textKeysToList(text_key)[[1]]
+    expect_null(getSettingValue(settings=none_settings,key=key))
+  }
+  
+  other_settings <- generateSettings(standard="a different standard") 
+  for(text_key in data_setting_keys){
+    key<-textKeysToList(text_key)[[1]]
+    expect_null(getSettingValue(settings=other_settings,key=key))
   }
   
   sdtm_settings <- generateSettings(standard="SDTM")
-  for(name in column_setting_names){
-    expect_is(sdtm_settings[[name]],"character")
+  for(text_key in data_setting_keys){
+    key<-textKeysToList(text_key)[[1]]
+    expect_is(getSettingValue(settings=sdtm_settings,key=key),"character")
   }
   
+  
   sdtm_settings2 <- generateSettings(standard="SdTm")
-  for(name in column_setting_names){
-    expect_is(sdtm_settings2[[name]],"character")
+  for(text_key in data_setting_keys){
+    key<-textKeysToList(text_key)[[1]]
+    expect_is(getSettingValue(settings=sdtm_settings2,key=key),"character")
   }
   
+  
   adam_settings <- generateSettings(standard="ADaM")
-  for(name in column_setting_names){
-    expect_is(adam_settings[[name]],"character")
+  for(text_key in data_setting_keys){
+    key<-textKeysToList(text_key)[[1]]
+    expect_is(getSettingValue(settings=adam_settings,key=key),"character")
   }
   
   adam_settings2 <- generateSettings(standard="ADAM")
-  for(name in column_setting_names){
-    expect_is(adam_settings2[[name]],"character")
+  for(text_key in data_setting_keys){
+    key<-textKeysToList(text_key)[[1]]
+    expect_is(getSettingValue(settings=adam_settings2,key=key),"character")
   }
   
+  
   # Test Partial Spec Match
-  partial_adam_settings <- generateSettings(standard="SDTM", partial=TRUE, partial_cols = c("USUBJID","TEST"))
-  for(name in column_setting_names){
-    
-    if (name %in% c("id_col","measure_col")) {
-      expect_is(partial_adam_settings[[name]],"character")
+  partial_adam_settings <- generateSettings(standard="adam", partial=TRUE, partial_keys = c("id_col","measure_col","measure_values--ALT"))
+  for(text_key in data_setting_keys){
+    key<-textKeysToList(text_key)[[1]]
+    if (text_key %in% c("id_col","measure_col","measure_values--ALT")) {
+      expect_is(getSettingValue(settings=partial_adam_settings,key=key),"character")
     } else {
-      expect_null(partial_adam_settings[[name]])
+      expect_null(getSettingValue(settings=partial_adam_settings,key=key))
     }
   }
   
   #Testing that partial cols are only used when partial=TRUE
-  full_adam_partial_cols <- generateSettings(standard="ADaM", partial_cols = c("USUBJID","TEST"))
-  for(name in column_setting_names){
-    expect_is(full_adam_partial_cols[[name]],"character")
+  full_adam_partial_cols <- generateSettings(standard="ADaM",  partial_keys = c("id_col","measure_col","measure_values--ALT"))
+  for(text_key in data_setting_keys){
+    key<-textKeysToList(text_key)[[1]]
+    expect_is(getSettingValue(settings=full_adam_partial_cols,key=key),"character")
   }
   
   #Testing failure when partial is true with no specified columns
   expect_error(partial_settings_no_cols <- generateSettings(standard="ADaM", partial=TRUE))
-  
-  
 })
diff --git a/tests/testthat/test_setSettingsValue.R b/tests/testthat/test_setSettingsValue.R
new file mode 100644
index 00000000..756a7ae4
--- /dev/null
+++ b/tests/testthat/test_setSettingsValue.R
@@ -0,0 +1,70 @@
+context("Tests for the setSettingValue() function")
+library(safetyGraphics)
+
+testSettings1<-list(a=list(x="sue",y="sam"), b="hi mom", c=123, unnamed=list("Apples","Oranges"))
+
+test_that("function throws an error if the settings object isn't a list",{
+  expect_error(setSettingsValue(key="testKey",value="abc", settings=c("NotAList")))
+  expect_silent(setSettingsValue(key="testKey", value="DEF", settings=list(testkey="ABC")))
+})
+
+test_that("can set values to/from various types",{
+  expect_equal(setSettingsValue("a", 456, testSettings1)[["a"]], 456)
+  expect_equal(setSettingsValue(list("a"), 456,testSettings1)[["a"]], 456)
+  expect_equal(setSettingsValue(list("a"), "sometext",testSettings1)[["a"]], "sometext")
+  expect_equal(setSettingsValue(list("a"), FALSE,testSettings1)[["a"]], FALSE)
+  expect_equal(setSettingsValue(list("b"), "hi dad",testSettings1)[["b"]], "hi dad")
+  expect_equal(setSettingsValue(list("b"), 123,testSettings1)[["b"]], 123)
+  expect_equal(setSettingsValue(list("b"), list(e=1,f=FALSE),testSettings1)[["b"]], list(e=1,f=FALSE))
+  expect_equal(setSettingsValue(list("c"), FALSE,testSettings1)[["c"]], FALSE)
+})
+
+test_that("can set value that didn't previously exist",{
+  expect_equal(setSettingsValue("d", "I'm new here.", testSettings1)[["d"]], "I'm new here.")
+  expect_equal(setSettingsValue(list("d"), "I'm new here.", testSettings1)[["d"]], "I'm new here.")
+})
+
+test_that("can set nested values",{
+  expect_equal(setSettingsValue(list("a","x"), 456, testSettings1)[["a"]][["x"]], 456)
+})
+
+test_that("can set nested values that didn't previously exist",{
+  expect_equal(setSettingsValue(list("a","z"), 456, testSettings1)[["a"]][["z"]], 456)
+})
+
+test_that("but can't set nested values when a parent is missing or isn't a list",{
+  expect_error(setSettingsValue(list("d","test"), 456, testSettings1)[["d"]][["test"]]) # d doesn't exist, so this doesn't work. user could set d to list() and then set test to 456 ... 
+  expect_error(setSettingsValue(list("b","z"), 456, testSettings1)) # can't replace a scalar (b="hi mom") with a list (b=list(z=456))
+})
+
+test_that("can set nested values in an unnamed list",{
+  expect_equal(setSettingsValue(list("unnamed",1), 456, testSettings1)[["unnamed"]][[1]], 456) # [[1]] is overwritten
+  expect_equal(setSettingsValue(list("unnamed",1), 456, testSettings1)[["unnamed"]][[2]], "Oranges") #original value in [[2]] is unchanged
+})
+
+test_that("can set nested values in an unnamed list that didn't previously exist",{
+  expect_true(setSettingsValue(list("unnamed",3), TRUE, testSettings1)[["unnamed"]][[3]]) #[[3]] added
+  
+  expect_true(setSettingsValue(list("unnamed",5), TRUE, testSettings1)[["unnamed"]][[5]]) #this works, [[4]] and [[5]] are Null
+  expect_null(setSettingsValue(list("unnamed",5), TRUE, testSettings1)[["unnamed"]][[4]]) #this works, [[4]] and [[5]] are Null
+  expect_null(setSettingsValue(list("unnamed",5), TRUE, testSettings1)[["unnamed"]][[4]]) #this works, [[4]] and [[5]] are Null
+})
+
+
+test_that("sanity checks using a real setting object",{
+  testSDTM <- generateSettings(standard="SDTM")
+  testSDTM <-setSettingsValue(list("id_col"), "customID", testSDTM)
+  testSDTM <-setSettingsValue(list("measure_values","ALP"), "Alpine", testSDTM)
+  testSDTM <-setSettingsValue(list("filters"), list(), testSDTM)
+  testSDTM <-setSettingsValue(list("filters",1), "RACE", testSDTM)
+  testSDTM <-setSettingsValue(list("customSetting"), "customized!", testSDTM)
+  
+  
+  expect_equal(testSDTM[["id_col"]],"customID")
+  expect_equal(testSDTM[["measure_values"]][["ALP"]],"Alpine")
+  expect_equal(testSDTM[["filters"]][[1]],"RACE")
+  expect_equal(testSDTM[["customSetting"]],"customized!")
+})
+
+
+  
\ No newline at end of file
diff --git a/tests/testthat/test_validateSettings.R b/tests/testthat/test_validateSettings.R
index 619ebdfd..9dcd151a 100644
--- a/tests/testthat/test_validateSettings.R
+++ b/tests/testthat/test_validateSettings.R
@@ -50,7 +50,7 @@ test_that("field checks fail when expected",{
   expect_equal(failedChecks[[1]][['check']],"'_values' field from setting found in data?")
   expect_equal(failedChecks[[1]][['text_key']],"measure_values--ALP")
 
-  invalidFieldSettings$visit_values <- list(test="not a visit",test2="still not a visit")
+  invalidFieldSettings$id_values <- list(test="not an id",test2="still not an id")
   fieldFailed2<-validateSettings(data=adlbc,settings=invalidFieldSettings)
   failedChecks2 = fieldFailed2[["checkList"]]%>%keep(~!.x[["valid"]])
   expect_false(fieldFailed[["valid"]])