add chart nodes

Author: grlloyd

DESCRIPTION

@@ -34,8 +34,9 @@ Collate:
     'chart_class.R'
     'stato_class.R'
     'DatasetExperiment_class.R'
-    'dag_execute.R'
     'struct_node_class.R'
+    'chart_node_class.R'
+    'dag_execute.R'
     'data_node_class.R'
     'entity_class.R'
     'entity_stato_class.R'

NAMESPACE

@@ -2,6 +2,7 @@
 
 S3method(.DollarNames,DatasetExperiment)
 S3method(.DollarNames,chart)
+S3method(.DollarNames,chart_node)
 S3method(.DollarNames,data_node)
 S3method(.DollarNames,iterator)
 S3method(.DollarNames,metric)
@@ -14,6 +15,7 @@ S3method(.DollarNames,preprocess)
 S3method(.DollarNames,resampler)
 S3method(.DollarNames,struct_class)
 S3method(.DollarNames,struct_node)
+export("chart<-")
 export("data_value<-")
 export("model<-")
 export("output_list<-")
@@ -30,6 +32,8 @@ export(as_data_frame)
 export(calculate)
 export(chart)
 export(chart_names)
+export(chart_node)
+export(chart_node_example)
 export(chart_plot)
 export(citations)
 export(dag_execute)
@@ -104,6 +108,7 @@ exportMethods("*")
 exportMethods("+")
 exportMethods("[")
 exportMethods("[<-")
+exportMethods("chart<-")
 exportMethods("data_value<-")
 exportMethods("max_length<-")
 exportMethods("model<-")
@@ -123,6 +128,7 @@ exportMethods(as.DatasetExperiment)
 exportMethods(as.SummarizedExperiment)
 exportMethods(as.code)
 exportMethods(calculate)
+exportMethods(chart)
 exportMethods(chart_names)
 exportMethods(chart_plot)
 exportMethods(citations)

R/chart_node_class.R

@@ -0,0 +1,112 @@
+#' chart_node class
+#'
+#' A class for representing chart nodes in a directed acyclic graph (DAG) of struct models.
+#' Each node contains a struct chart object that will be executed using chart_plot.
+#' Chart nodes can have multiple input objects (e.g., a model and a dataset).
+#'
+#' @section \code{chart} slot:
+#' The "chart" slot holds a struct chart object that will be executed when the node is processed using chart_plot.
+#'
+#' @section \code{input_objects} slot:
+#' The "input_objects" slot holds a list of input objects that will be passed to chart_plot.
+#' The order of objects in this list corresponds to the order of parameters in the chart_plot method.
+#'
+#' @export chart_node
+#' @param name the name of the node
+#' @param description a description of the node
+#' @param chart a struct chart object
+#' @param ... additional parameters to pass to struct_class
+#' @include generics.R struct_class.R struct_node_class.R chart_class.R
+#' @examples
+#' C = example_chart()
+#' NODE = chart_node(name = 'Example Chart Node', description = 'A simple example chart node', chart = C)
+#' @rdname chart_node
+chart_node = function(name = character(0), description = character(0), chart = NULL, ...) {
+    # new object
+    out = new_struct('chart_node',
+        name = name,
+        description = description,
+        chart = chart,
+        ...)
+    return(out)
+}
+
+.chart_node <- setClass(
+    "chart_node",
+    contains = c('struct_node'),
+    slots = c(
+        chart = 'struct_class',
+        input_objects = 'list'
+    ),
+    prototype = list(
+        chart = NULL,
+        input_objects = list()
+    )
+)
+
+#' @rdname chart
+#' @export
+#' @examples
+#' C = example_chart()
+#' NODE = chart_node(chart = C)
+#' chart(NODE)
+#' @return the chart object in the node
+setGeneric("chart", function(object) standardGeneric("chart"))
+
+#' @rdname chart
+#' @export
+setMethod(f = "chart",
+    signature = c("chart_node"),
+    definition = function(object) {
+        return(object@chart)
+    }
+)
+
+#' @rdname chart
+#' @export
+#' @examples
+#' C = example_chart()
+#' NODE = chart_node()
+#' chart(NODE) = C
+#' @return the modified node object
+setGeneric("chart<-", function(object, value) standardGeneric("chart<-"))
+
+#' @rdname chart
+#' @export
+setMethod(f = "chart<-",
+    signature = c("chart_node", "struct_class"),
+    definition = function(object, value) {
+        object@chart = value
+        return(object)
+    }
+)
+
+setMethod(f = "show",
+    signature = c("chart_node"),
+    definition = function(object) {
+        callNextMethod()
+        if (!is.null(object@chart)) {
+            cat('chart:         ', class(object@chart)[1], '\n', sep = '')
+        } else {
+            cat('chart:         NULL\n', sep = '')
+        }
+        if (length(object@input_objects) > 0) {
+            cat('input objects: ', length(object@input_objects), ' objects\n', sep = '')
+        } else {
+            cat('input objects: none\n', sep = '')
+        }
+        cat('\n')
+    }
+)
+
+# autocompletion
+#' @export
+#' @rdname autocompletion
+#' @method .DollarNames chart_node
+.DollarNames.chart_node <- function(x, pattern = "") {
+    .DollarNames.struct_class(x, pattern)
+}
+
+#' @export
+#' @rdname autocompletion
+setMethod('.DollarNames','chart_node',.DollarNames.chart_node) 

R/dag_execute.R

@@ -65,8 +65,8 @@ setMethod(f = "dag_execute",
         # Check that all nodes are valid
         for (node_name in names(nodes)) {
             node = nodes[[node_name]]
-            if (!is(node, 'model_node') && !is(node, 'data_node') && !is(node, 'prediction_node')) {
-                stop('Node "', node_name, '" must be a model_node, data_node, or prediction_node object')
+            if (!is(node, 'model_node') && !is(node, 'data_node') && !is(node, 'prediction_node') && !is(node, 'chart_node')) {
+                stop('Node "', node_name, '" must be a model_node, data_node, prediction_node, or chart_node object')
             }
         }
 
@@ -333,6 +333,93 @@ setMethod(f = "dag_execute",
                         cat('  Model output: ', class(result)[1], '\n')
                     }
                 }
+            } else if (is(current_node, 'chart_node')) {
+                # Chart nodes: execute chart_plot
+                
+                # Find all input objects for this node
+                input_objects = list()
+                
+                # Look for edges pointing to this node
+                for (edge in dag$edges) {
+                    if (edge$to == current) {
+                        from_node = edge$from
+                        from_param = edge$from_param
+                        to_param = edge$to_param
+                        
+                        if (from_node %in% names(results)) {
+                            from_output = results[[from_node]]
+                            from_node_obj = nodes[[from_node]]
+                            
+                            # Handle different from_param values
+                            if (from_param == "asis" || is.null(from_param)) {
+                                # Pass the object as-is (for data nodes)
+                                input_value = from_output
+                            } else if (from_param == "predicted") {
+                                # Use predicted() output (for model nodes to other model nodes)
+                                if (is(from_output, 'struct_class') && is(from_output, 'model')) {
+                                    tryCatch({
+                                        input_value = predicted(from_output)
+                                    }, error = function(e) {
+                                        stop('Failed to get predicted output from ', from_node, ': ', e$message)
+                                    })
+                                } else {
+                                    stop('Cannot get predicted output from non-model node: ', from_node)
+                                }
+                            } else {
+                                # Use named slot/parameter
+                                if (is(from_output, 'struct_class')) {
+                                    tryCatch({
+                                        input_value = from_output[[from_param]]
+                                    }, error = function(e) {
+                                        stop('Failed to get parameter "', from_param, '" from ', from_node, ': ', e$message)
+                                    })
+                                } else {
+                                    stop('Cannot get parameter from non-struct object: ', from_node)
+                                }
+                            }
+                            
+                            # Handle different to_param values for chart nodes
+                            if (to_param == "input_object" || is.null(to_param)) {
+                                # Add to input_objects list in order
+                                input_objects = c(input_objects, list(input_value))
+                            } else {
+                                # Set named parameter for the chart
+                                chart_obj = chart(current_node)
+                                chart_obj[[to_param]] = input_value
+                                current_node@chart = chart_obj
+                            }
+                        }
+                    }
+                }
+                
+                # Set the input_objects for the current node
+                current_node@input_objects = input_objects
+                
+                if (verbose) {
+                    cat('  Executing chart: ', class(chart(current_node))[1], ' with chart_plot\n')
+                }
+                
+                # Execute the chart using chart_plot
+                chart_obj = chart(current_node)
+                
+                # Call chart_plot with the chart object and input objects
+                if (length(input_objects) == 0) {
+                    # No input objects, just call chart_plot with the chart
+                    result = chart_plot(chart_obj)
+                } else if (length(input_objects) == 1) {
+                    # Single input object
+                    result = chart_plot(chart_obj, input_objects[[1]])
+                } else {
+                    # Multiple input objects - use do.call to pass them as arguments
+                    result = do.call(chart_plot, c(list(chart_obj), input_objects))
+                }
+                
+                # Store the result (chart_plot returns a plot object)
+                results[[current]] = result
+                
+                if (verbose) {
+                    cat('  Chart output: plot object of class ', class(result)[1], '\n')
+                }
             }
 
             # Update in-degrees and add new sources to queue

R/example_objects.R

@@ -165,6 +165,42 @@ setMethod(f = "chart_plot",
     }
 )
 
+#' @export
+#' @examples
+#' # Example of using chart_node with multiple inputs
+#' # This shows how to create a chart node that takes both a model and a dataset
+#' D = iris_DatasetExperiment()
+#' M = structToolbox::glog_transform(qc_label='versicolor',factor_name='Species')
+#' M = model_apply(M,D)
+#' C = structToolbox::glog_opt_plot()
+#' 
+#' # Create chart node
+#' chart_node1 = chart_node(name = 'Glog Chart', description = 'Glog optimization plot', chart = C)
+#' 
+#' # Create DAG with chart node
+#' dag = model_dag(
+#'     name = 'Chart Example DAG',
+#'     description = 'Example DAG with chart node',
+#'     edges = list(
+#'         list(from = 'Data', from_param = 'asis', to = 'Model', to_param = 'input_data'),
+#'         list(from = 'Model', from_param = 'asis', to = 'Chart', to_param = 'input_object'),
+#'         list(from = 'Data', from_param = 'asis', to = 'Chart', to_param = 'input_object')
+#'     ),
+#'     nodes = list(
+#'         'Data' = data_node(name = 'Data', data = D),
+#'         'Model' = model_node(name = 'Model', model = M),
+#'         'Chart' = chart_node1
+#'     )
+#' )
+#' 
+#' # Execute DAG
+#' dag = dag_execute(dag)
+chart_node_example = function() {
+    # This is a placeholder for the example
+    # The actual example is in the documentation above
+    return(NULL)
+}
+