Skip to content
Snippets Groups Projects
Select Git revision
  • 615263259376fd4906fa12374ce6042f5d4799e5
  • master default
  • petsc-uname
  • hdf5-uname
  • snakemake-7.21
  • unmerged-fixes
  • petsc-repro
  • base-for-issue-62196
  • v1.4.0
  • v1.4.0rc2
  • v1.4.0rc1
  • v1.3.0
  • v1.3.0rc2
  • v1.3.0rc1
  • v1.2.0
  • v1.2.0rc2
  • v1.2.0rc1
  • v1.1.0
  • v1.1.0rc2
  • v1.1.0rc1
  • bootstrap-20190815
  • v1.0.1
  • v1.0.0
  • v0.16.0
  • v0.15.0
  • v0.14.0
  • v0.13.0
27 results

configure.ac

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    ogs6.R 12.15 KiB
    
    
    #============================== R6 ================================
    
    #'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
      )
    )