ogs6.R

#===== OGS6 documentation =====

#'OGS6
#'
#'The OpenGeoSys6 simulation class, core of the r2ogs6 package
#'
#'@docType class
#'
#'
NULL

#===== OGS6 =====


#'OGS6
#'@description Constructor for the OGS6 base class
#'@param sim_name The name of the simulation
#'@param sim_id The ID of the simulation
#'@param sim_path The path where all relevant files for the simulation will be
#' saved
#'@param ogs_bin_path Path to OpenGeoSys6 /bin directory
#'@param test_mode In test mode, sim_path and ogs_bin_path will not be
#' validated. If you're not a developer, please leave this variable as it is :)
#'@export
OGS6 <- R6::R6Class("OGS6",
  public = list(

    initialize = function(sim_name,
                          sim_id,
                          sim_path,
                          ogs_bin_path,
                          test_mode = FALSE) {

      # Basic validation
      assertthat::assert_that(assertthat::is.string(sim_name))
      assertthat::assert_that(assertthat::is.number(sim_id))
      assertthat::assert_that(assertthat::is.string(sim_path))
      assertthat::assert_that(assertthat::is.string(ogs_bin_path))

      if(!test_mode){
        validate_paths(sim_path, ogs_bin_path)
      }

        private$.sim_output <- list()

        private$.sim_name <- sim_name
        private$.sim_id <- sim_id
        private$.sim_path <- sim_path
        private$.ogs_bin_path <- ogs_bin_path
    },

    add_sim_output = function(name, value) {
        private$.sim_output[[name]] <- value
    },

    add_mesh = function(mesh){
      assertthat::assert_that(class(mesh) == "r2ogs6_mesh")
      private$.meshes <- c(private$.meshes, list(mesh))
    },

    add_gml = function(gml){
      assertthat::assert_that(class(gml) == "r2ogs6_gml")
      if(!is.null(private$.gml)){
        warning("Overwriting gml and geometry variable of OGS6 object",
                call. = FALSE)

      }
      private$.gml <- gml
      private$.geometry <- paste0(gml$name, ".gml")
    },

    add_python_script = function(python_script){
      assertthat::assert_that(assertthat::is.string(python_script))
      if(!is.null(private$.python_script)){
        warning("Overwriting python_script variable of OGS6 object",
                call. = FALSE)

      }
      private$.python_script <- python_script
    },

    add_process = function(process){
      assertthat::assert_that(class(process) == "r2ogs6_process")
      private$.processes <- c(private$.processes, list(process))
    },

    add_time_loop = function(time_loop){
      assertthat::assert_that(class(time_loop) == "r2ogs6_time_loop")
      if(!is.null(private$.time_loop)){
        warning("Overwriting time_loop variable of OGS6 object", call. = FALSE)
      }
      private$.time_loop <- time_loop
    },

    add_local_coordinate_system = function(local_coordinate_system){
      assertthat::assert_that(class(local_coordinate_system) ==
                                "r2ogs6_local_coordinate_system")
      if(!is.null(private$.local_coordinate_system)){
        warning("Overwriting local_coordinate_system variable of OGS6 object",
                call. = FALSE)
      }
      private$.local_coordinate_system <- local_coordinate_system
    },

    add_medium = function(medium){
      assertthat::assert_that(class(medium) == "r2ogs6_medium")
      private$.media <- c(private$.media, list(medium))
    },

    add_parameter = function(parameter){
      assertthat::assert_that(class(parameter) == "r2ogs6_parameter")
      private$.parameters <- c(private$.parameters, list(parameter))
    },

    add_curve = function(curve){
      assertthat::assert_that(class(curve) == "r2ogs6_curve")
      private$.curves <- c(private$.curves, list(curve))
    },

    add_process_variable = function(process_variable){
      assertthat::assert_that(class(process_variable) ==
                                "r2ogs6_process_variable")
      private$.process_variables <- c(private$.process_variables,
                                      list(process_variable))
    },

    add_nonlinear_solver = function(nonlinear_solver){
      assertthat::assert_that(class(nonlinear_solver) ==
                                "r2ogs6_nonlinear_solver")
      private$.nonlinear_solvers <- c(private$.nonlinear_solvers,
                                      list(nonlinear_solver))
    },

    add_linear_solver = function(linear_solver){
      assertthat::assert_that(class(linear_solver) == "r2ogs6_linear_solver")
      private$.linear_solvers <- c(private$.linear_solvers, list(linear_solver))
    },

    add_vtkdiff = function(vtkdiff){
      assertthat::assert_that(class(vtkdiff) == "r2ogs6_vtkdiff")
      private$.test_definition <- c(private$.test_definition, list(vtkdiff))
    },

    add_insitu = function(insitu){
      assertthat::assert_that(class(insitu) == "r2ogs6_insitu")

      if(!is.null(private$.insitu)){
        warning("Overwriting insitu variable of OGS6 object", call. = FALSE)
      }
      private$.insitu <- insitu
    },

    get_status = function(){

      flag <- TRUE

      #.gml
      #flag <- obj_is_defined(flag, private$.gml, "gml")

      #.vtu
      flag <- get_list_status(flag, private$.meshes, "mesh")

      #.prj
      flag <- get_list_status(flag, private$.processes, "process")
      flag <- obj_is_defined(flag, private$.time_loop, "time_loop")
      flag <- obj_is_defined(flag, private$.local_coordinate_system,
                             "local_coordinate_system", is_opt = TRUE)
      flag <- get_list_status(flag, private$.media, "medium", is_opt = TRUE)
      flag <- get_list_status(flag, private$.parameters, "parameter")
      flag <- get_list_status(flag, private$.curves, "curve", is_opt = TRUE)
      flag <- get_list_status(flag, private$.process_variables,
                              "process_variable")
      flag <- get_list_status(flag, private$.nonlinear_solvers,
                              "nonlinear_solver")
      flag <- get_list_status(flag, private$.linear_solvers,
                              "linear_solver")
      flag <- get_list_status(flag, private$.test_definition,
                              "vtkdiff", is_opt = TRUE)
      flag <- obj_is_defined(flag, private$.insitu,
                             "insitu", is_opt = TRUE)

      if(flag){
        cat(paste0("Your simulation object has all necessary components.\n",
        "You can try to start the simulation by calling run_simulation() ",
        "on your OGS6 object.\n",
        "Note that this will call more validation functions, ",
        "so you may not be done just yet.\n"))
      }

      return(invisible(flag))
    },

    clear = function(which = names(get_implemented_classes())){

      assertthat::assert_that(is.character(which))

      valid_input = names(get_implemented_classes())

      null_it <- c("geometry", "time_loop")

      for(i in seq_len(length(which))){
        if(!which[[i]] %in% valid_input){
          warning(paste0("Parameter '", which[[i]],
                         "' not recognized by OGS6$clear(). ",
                        "Valid parameters are:\n'",
                        paste(valid_input, sep = "", collapse = "', '"),
                        "'\nSkipping."), call. = FALSE)
          next
        }else{
          call_str <- ""
          if(which[[i]] %in% null_it){
            call_str <- paste0("private$.", which[[i]], " <- NULL")
          }else{
            call_str <- paste0("private$.", which[[i]], " <- list()")
          }
          eval(parse(text = call_str))
        }
      }
    }

  ),

  active = list(
      sim_output = function(value) {
        if (missing(value)) {
          private$.sim_output
        } else {
          stop("To modify `$sim_output`, use set_sim_output().", call. = FALSE)
        }
      },

      sim_name = function(value) {
          if (missing(value)) {
              private$.sim_name
          } else {
              stop("`$sim_name` is read only", call. = FALSE)
          }
      },

      sim_id = function(value) {
          if (missing(value)) {
              private$.sim_id
          } else {
              stop("`$sim_id` is read only", call. = FALSE)
          }
      },

      sim_path = function(value) {
          if (missing(value)) {
              private$.sim_path
          } else {
              stop("`$sim_path` is read only", call. = FALSE)
          }
      },

      ogs_bin_path = function(value) {
        if (missing(value)) {
          private$.ogs_bin_path
        } else {
          stop("`$ogs_bin_path` is read only", call. = FALSE)
        }
      },

      gml = function(value) {
        if (missing(value)) {
          private$.gml
        } else {
          stop("`To modify `$gml`, use add_gml().", call. = FALSE)
        }
      },

      meshes = function(value) {
        if (missing(value)) {
          private$.meshes
        } else {
          stop("`$meshes` is read only", call. = FALSE)
        }
      },

      geometry = function(value) {
        if (missing(value)) {
          private$.geometry
        } else {
          stop("`$geometry` is read only", call. = FALSE)
        }
      },

      python_script = function(value) {
        if (missing(value)) {
          private$.python_script
        } else {
          stop("`$python_script` is read only", call. = FALSE)
        }
      },

      processes = function(value) {
        if (missing(value)) {
          private$.processes
        } else {
          stop("`To modify `$processes`, use add_process().", call. = FALSE)
        }
      },

      time_loop = function(value) {
        if (missing(value)) {
          private$.time_loop
        } else {
          stop("`To modify `$time_loop`, use add_time_loop().", call. = FALSE)
        }
      },

      local_coordinate_system = function(value) {
        if (missing(value)) {
          private$.local_coordinate_system
        } else {
          stop(paste("`To modify `$local_coordinate_system`,",
                     "use add_local_coordinate_system()."),
               call. = FALSE)
        }
      },

      media = function(value) {
        if (missing(value)) {
          private$.media
        } else {
          stop("`To modify `$media`, use add_medium().", call. = FALSE)
        }
      },

      parameters = function(value) {
        if (missing(value)) {
          private$.parameters
        } else {
          stop("`To modify `$parameters`, use add_parameter().", call. = FALSE)
        }
      },

      curves = function(value) {
        if (missing(value)) {
          private$.curves
        } else {
          stop("`To modify `$curves`, use add_curve().", call. = FALSE)
        }
      },

      process_variables = function(value) {
        if (missing(value)) {
          private$.process_variables
        } else {
          stop("`To modify `$process_variables`, use add_process_variable().",
               call. = FALSE)
        }
      },

      nonlinear_solvers = function(value) {
        if (missing(value)) {
          private$.nonlinear_solvers
        } else {
          stop("`To modify `$nonlinear_solvers`, use add_nonlinear_solver().",
               call. = FALSE)
        }
      },

      linear_solvers = function(value) {
        if (missing(value)) {
          private$.linear_solvers
        } else {
          stop("`To modify `$linear_solvers`, use add_linear_solver().",
               call. = FALSE)
        }
      },

      test_definition = function(value) {
        if (missing(value)) {
          private$.test_definition
        } else {
          stop("`To modify `$test_definition`, use add_vtkdiff().",
               call. = FALSE)
        }
      },

      insitu = function(value) {
        if (missing(value)) {
          private$.insitu
        } else {
          stop("`To modify `$insitu`, use add_insitu().", call. = FALSE)
        }
      }
  ),

  private = list(
    #general parameters
      .sim_output = NULL,
      .sim_name = NULL,
      .sim_id = NULL,
      .sim_path = NULL,
      .ogs_bin_path = NULL,

      #.gml parameters
      .gml = NULL,

      #.prj parameters
      .meshes = list(),
      .geometry = NULL,
      .python_script = NULL,
      .processes = list(),
      .time_loop = NULL,
      .local_coordinate_system = NULL,
      .media = list(),
      .parameters = list(),
      .curves = list(),
      .process_variables = list(),
      .nonlinear_solvers = list(),
      .linear_solvers = list(),
      .test_definition = list(),
      .insitu = NULL
  )
)