FIMS coverage - 84.98%

Files
Source

# To remove the WARNING
# no visible binding for global variable
utils::globalVariables(c(
  "distribution_link", "distribution_type",
  "fleet_name",
  "type", "name", "value", "unit", "uncertainty",
  "timing", "age", "length", "year",
  "temp_name",
  "valid_n"
))

#' Initialize a generic module
#'
#' @description
#' Initializes a generic module by setting up its fields based on the provided
#' `module_name`.
#' @param parameters A tibble. Contains parameters and modules required for
#'   initialization.
#' @param data An S4 object. FIMS input data.
#' @param module_name A character. Name of the module to initialize (e.g.,
#'   "Population" or "Fleet").
#' @param fleet_name A character. Name of the fleet to initialize. If not
#'   specified, the module will be initialized without fleet-specific data.
#' @return
#' The initialized module as an object.
#' @noRd
initialize_module <- function(parameters, data, module_name, fleet_name = NA_character_) {
  module_input <- parameters |>
    # Using !! to unquote the variables
    dplyr::filter(module_name == !!module_name)

  if (!is.na(fleet_name)) {
    module_input <- module_input |>
      dplyr::filter(fleet_name == !!fleet_name)
  }

  module_class_name <- module_input |>
    # Combine module_type and module_name into a single string
    dplyr::mutate(
      temp_name = paste0(
        # Replace NAs with ""
        dplyr::coalesce(module_type, ""),
        dplyr::coalesce(module_name, "")
      )
    ) |>
    dplyr::pull(temp_name) |>
    unique()

  module_class <- get(module_class_name)
  module_fields <- names(module_class@fields)
  module <- methods::new(module_class)

  if (module_class_name == "Population") {
    module_fields <- setdiff(module_fields, c(
      "log_f_multiplier",
      "spawning_biomass_ratio"
    ))
  }

  if (module_class_name == "Fleet") {
    # Remove certain fields for the Fleet module
    module_fields <- setdiff(module_fields, c(
      "log_index_expected",
      "log_landings_expected",
      "index_expected",
      "landings_expected",
      "agecomp_expected",
      "agecomp_proportion",
      "observed_index_units",
      "observed_landings_units"
    ))

    fleet_types <- get_data(data) |>
      dplyr::filter(name == fleet_name) |>
      dplyr::pull(type) |>
      unique()

    data_distribution_names_for_fleet_i <- parameters |>
      dplyr::filter(fleet_name == !!fleet_name & distribution_type == "Data") |>
      dplyr::pull(module_type)
    if ("age_to_length_conversion" %in% fleet_types &&
      "LengthComp" %in% data_distribution_names_for_fleet_i) {
      age_to_length_conversion_value <- model_age_to_length_conversion(data, fleet_name)
      module[["age_to_length_conversion"]]$resize(length(age_to_length_conversion_value))
      # Assign each value to the corresponding position in the parameter vector
      purrr::walk(
        seq_along(age_to_length_conversion_value),
        \(x) module[["age_to_length_conversion"]][x][["value"]] <- age_to_length_conversion_value[x]
      )

      # Set the estimation information for the entire parameter vector
      module[["age_to_length_conversion"]]$set_all_estimable(FALSE)

      module[["age_to_length_conversion"]]$set_all_random(FALSE)
    } else {
      module_fields <- setdiff(module_fields, c(
        # Right now we can also remove n_lengths because the default is 0
        "n_lengths"
      ))
    }

    module_fields <- setdiff(module_fields, c(
      "age_to_length_conversion",
      "lengthcomp_expected",
      "lengthcomp_proportion"
    ))
  }

  # Populate fields based on common and specific settings
  # TODO:
  # - Population interface
  #   - Update the Population interface to consistently use n_ages and n_years,
  #     as done in the S4 data_big object.
  #     Update as needed.
  #   - Add n_fleets to data_big. Should n_fleets include both
  #     fishing and survey fleets? Currently, data_big@fleets equals 1.
  # - Fleet
  #   - Reconsider exposing `log_expected_index` and
  #     `agecomp_proportion` to users. Their IDs are linked with
  #     index and agecomp distributions. No input values are required.

  integer_fields <- c(
    "n_ages", "n_fleets", "n_lengths",
    "n_years"
  )

  boolean_fields <- c(
    "estimate_prop_female"
  )

  real_vector_fields <- c(
    "ages", "weights"
  )

  for (field in module_fields) {
    if (field %in% integer_fields) {
      module[[field]]$set(
        switch(field,
          "n_ages" = get_n_ages(data),
          "n_fleets" = parameters |>
            dplyr::filter(module_name == "Fleet") |>
            dplyr::pull(fleet_name) |>
            unique() |>
            length(),
          # Or we can use get_n_fleets(data),
          "n_lengths" = get_n_lengths(data),
          "n_years" = get_n_years(data)
        )
      )
    } else if (field %in% c("ages", "weights")) {
      get_value_function <- switch(field,
        "ages" = get_ages,
        "weights" = model_weight_at_age
      )
      module_length <- switch(field,
        "ages" = get_n_ages(data),
        "weights" = get_n_ages(data) * (get_n_years(data) + 1)
      )
      module[[field]]$resize(module_length)
      purrr::walk(
        seq(module_length),
        function(x) {
        module[[field]]$set(x - 1, get_value_function(data)[x])
      })
    } else {
      set_param_vector(
        field = field,
        module = module,
        module_input = module_input
      )
    }
  }
  return(module)
}

# TODO: Determine the relationship between distributions and the
# recruitment module, and implement the appropriate logic to retrieve
# distribution information.

#' Initialize a distribution module
#'
#' @description
#' Initializes a distribution module by setting up its fields based on the
#' distribution name and type. Supports both "data" and "process" types.
#' @param module_input A list. Contains parameters for initializing the
#'   distribution.
#' @param distribution_name A character. Name of the distribution to initialize.
#' @param distribution_type A character. Type of distribution, either "data" or
#'   "process".
#' @param linked_ids A vector. Named vector of linked IDs required for the
#'   distribution, such as data_link and fleet_link for setting up index
#'   distribution.
#' @rdname initialize_module
#' @return
#' The initialized distribution module as an object.
#' @noRd
initialize_distribution <- function(
  module_input,
  distribution_name,
  distribution_type = c("data", "process"),
  linked_ids
) {
  # Input checks
  # Check if distribution_name is provided
  if (is.null(distribution_name)) {
    return(NULL)
  }
  # Validate module_input
  if (!is.list(module_input)) {
    cli::cli_abort("{.var module_input} must be a list.")
  }
  # Validate distribution_type as "data" or "process"
  distribution_type <- rlang::arg_match(distribution_type)
  # Validate linked_ids as a named vector with required elements for "data" type
  if (!is.vector(linked_ids) ||
    !all(c("data_link", "fleet_link") %in% names(linked_ids))
  ) {
    cli::cli_abort(
      "{.var linked_ids} must be a named vector containing 'data_link' and
      'fleet_link' for 'data' distribution types."
    )
  }

  # Get distribution value and initialize the module
  distribution_value <- get(distribution_name)
  distribution_module <- methods::new(distribution_value)
  distribution_fields <- names(distribution_value@fields)
  if (distribution_type == "data") {
    distribution_fields <- setdiff(
      distribution_fields,
      c("expected_values", "observed_values", "dims")
    )
  }

  distribution_input_names <- grep(
    distribution_name,
    names(module_input),
    value = TRUE
  )
  for (field in distribution_fields) {
    set_param_vector(
      field = field, module = distribution_module,
      module_input = module_input[distribution_input_names]
    )
  }

  switch(distribution_type,
    "data" = {
      # Data distribution initialization
      distribution_module$set_observed_data(linked_ids["data_link"])
      distribution_module$set_distribution_links(
        distribution_type,
        linked_ids["fleet_link"]
      )
    },
    "process" = {
      # Process distribution initialization
      distribution_module$set_distribution_links("random_effects", linked_ids)
    }
  )

  # Final message to confirm success
  cli::cli_inform(c(
    "i" = "{distribution_name} initialized successfully for
          {names(distribution_name)}."
  ))

  return(distribution_module)
}

#' Initialize a recruitment module
#'
#' @description
#' Initializes a recruitment module by setting up fields. This function uses
#' the `initialize_module` function to handle specific requirements for
#' recruitment initialization.
#' @inheritParams initialize_module
#' @return
#' The initialized recruitment module as an object.
#' @noRd
initialize_recruitment <- function(parameters, data) {
  module <- initialize_module(
    parameters = parameters,
    data = data,
    module_name = "Recruitment"
  )
  return(module)
}

#' Initialize a growth module
#'
#' @description
#' Initializes a growth module by setting up fields. This function uses
#' the `initialize_module` function to handle specific requirements for
#' growth initialization.
#' @inheritParams initialize_module
#' @return
#' The initialized growth module as an object.
#' @noRd
initialize_growth <- function(parameters, data) {
  module <- initialize_module(
    parameters = parameters,
    data = data,
    module_name = "Growth"
  )
  return(module)
}

#' Initialize a maturity module
#'
#' @description
#' Initializes a maturity module by setting up fields. This function uses
#' the `initialize_module` function to handle specific requirements for
#' maturity initialization.
#' @inheritParams initialize_module
#' @return
#' The initialized maturity module as an object.
#' @noRd
initialize_maturity <- function(parameters, data) {
  module <- initialize_module(
    parameters = parameters,
    data = data,
    module_name = "Maturity"
  )
  return(module)
}

#' Initialize a population module.
#'
#' @description
#' Initializes a population module by setting up fields. This function uses
#' the `initialize_module` function to handle specific requirements for
#' population initialization.
#' @inheritParams initialize_module
#' @param linked_ids A vector. Named vector of linked IDs required for the
#'   population, including IDs for "growth", "maturity", and "recruitment".
#' @return
#' The initialized population module as an object.
#' @noRd
initialize_population <- function(parameters, data, linked_ids) {
  if (anyNA(linked_ids[c("growth", "maturity", "recruitment")])) {
    cli::cli_abort(c(
      "{.var linked_ids} for population must include `growth`, `maturity`, and
      `recruitment` IDs."
    ))
  }

  module <- initialize_module(
    parameters = parameters,
    data = data,
    module_name = "Population"
  )

  # Link up the recruitment, growth, and maturity modules with
  # this population module
  module$SetGrowthID(linked_ids[["growth"]])
  module$SetMaturityID(linked_ids[["maturity"]])
  module$SetRecruitmentID(linked_ids[["recruitment"]])
  # Link fleets to module
  for (i in which(grepl("fleet", names(linked_ids)))) {
    module$AddFleet(linked_ids[[i]])
  }

  return(module)
}

#' Initialize a selectivity module.
#'
#' @description
#' Initializes a selectivity module by setting up fields. This function uses
#' the `initialize_module` function to handle specific requirements for
#' population initialization.
#'
#' For logistic selectivity, the curve can be either ascending or descending
#' based on the sign of the slope parameter. A positive slope creates an
#' ascending logistic curve where selectivity increases from 0 to 1 with
#' increasing values of the independent variable (e.g., age or size). A
#' negative slope creates a descending logistic curve where selectivity
#' decreases from 1 to 0.
#'
#' @inheritParams initialize_module
#' @param fleet_name A character. Name of the fleet to initialize.
#' @return
#' The initialized selectivity module as an object.
#' @noRd
initialize_selectivity <- function(parameters, data, fleet_name) {
  module_name <- "Selectivity"
  module <- initialize_module(
    parameters = parameters,
    data = data,
    module_name = module_name,
    fleet_name = fleet_name
  )
  return(module)
}

# TODO: Do we want to put initialize_selectivity(), initialize_index(), and
# initial_age_comp() inside of initialize_fleet()?

#' Initialize a fleet module
#'
#' @description
#' Initializes a fleet module by setting up its fields. It links selectivity,
#' index, and age-composition modules.
#' @inheritParams initialize_module
#' @param fleet_name A character. Name of the fleet to initialize.
#' @param linked_ids A vector. Named vector of linked IDs required for the
#'  fleet, including IDs for "selectivity", "landings", "index", "age_comp", and "length_comp".
#' @return
#' The initialized fleet module as an object.
#' @noRd
initialize_fleet <- function(parameters, data, fleet_name, linked_ids) {
  module <- initialize_module(
    parameters = parameters,
    data = data,
    fleet_name = fleet_name,
    module_name = "Fleet"
  )

  module$SetSelectivityID(linked_ids["selectivity"])

  fleet_types <- get_data(data) |>
    dplyr::filter(name == fleet_name) |>
    dplyr::pull(type) |>
    unique()


  distribution_names_for_fleet <- parameters |>
    dplyr::filter(fleet_name == !!fleet_name & distribution_type == "Data") |>
    dplyr::pull(module_type)

  # Link the observed landings data to the fleet module using its associated ID
  # if the data type includes "landings" and if "Landings" exists in the data distribution
  # specification
  if ("landings" %in% fleet_types &&
    "Landings" %in% distribution_names_for_fleet) {
    module$SetObservedLandingsDataID(linked_ids["landings"])
  }

  # Link the observed index data to the fleet module using its associated ID
  # if the data type includes "index" and if "Index" exists in the data distribution
  # specification
  if ("index" %in% fleet_types &&
    "Index" %in% distribution_names_for_fleet) {
    module$SetObservedIndexDataID(linked_ids["index"])
  }

  # Link the observed age composition data to the fleet module using its associated ID
  # if the data type includes "age_comp" and if "AgeComp" exists in the data distribution
  # specification
  if ("age_comp" %in% fleet_types &&
    "AgeComp" %in% distribution_names_for_fleet) {
    module$SetObservedAgeCompDataID(linked_ids["age_comp"])
  }

  # Link the observed length composition data to the fleet module using its associated ID
  # if the data type includes "length_comp" and if "LengthComp" exists in the data
  # distribution specification
  if ("length_comp" %in% fleet_types &&
    "LengthComp" %in% distribution_names_for_fleet) {
    module$SetObservedLengthCompDataID(linked_ids["length_comp"])
  }
  return(module)
}

#' Initialize a landings module
#'
#' @description
#' Initializes a landings module based on the provided data and fleet name.
#' @inheritParams initialize_module
#' @param fleet_name A character. Name of the fleet for which the landings module
#'   is initialized.
#' @return
#' The initialized landings module as an object.
#' @noRd
initialize_landings <- function(data, fleet_name) {
  # Check if the specified fleet exists in the data
  fleet_exists <- any(get_data(data)["name"] == fleet_name)
  if (!fleet_exists) {
    cli::cli_abort("Fleet {fleet_name} not found in the data object.")
  }

  fleet_type <- dplyr::filter(
    .data = as.data.frame(get_data(data)),
    name == fleet_name
  ) |>
    dplyr::distinct(type) |>
    dplyr::pull(type)

  if ("landings" %in% fleet_type) {
    module <- methods::new(Landings, get_n_years(data))
    purrr::walk(
      seq_along(model_landings(data, fleet_name)),
      \(x) module$landings_data$set(x - 1, model_landings(data, fleet_name)[x])
    )
    return(module)
  } else {
    return(NULL)
  }
}

#' Initialize an index module
#'
#' @description
#' Initializes an index module based on the provided data and fleet name.
#' @inheritParams initialize_module
#' @param fleet_name A character. Name of the fleet for which the index module
#'   is initialized.
#' @return
#' The initialized index module as an object.
#' @noRd
initialize_index <- function(data, fleet_name) {
  # Check if the specified fleet exists in the data
  fleet_exists <- any(get_data(data)["name"] == fleet_name)
  if (!fleet_exists) {
    cli::cli_abort("Fleet {fleet_name} not found in the data object.")
  }

  fleet_type <- dplyr::filter(
    .data = as.data.frame(get_data(data)),
    name == fleet_name
  ) |>
    dplyr::distinct(type) |>
    dplyr::pull(type)

  if ("index" %in% fleet_type) {
    module <- methods::new(Index, get_n_years(data))
    purrr::walk(
      seq_along(model_index(data, fleet_name)),
      \(x) module$index_data$set(x - 1, model_index(data, fleet_name)[x])
    )
    return(module)
  } else {
    return(NULL)
  }
}

#' Initialize a composition module
#'
#' Several types of composition modules exist and this function acts as a
#' generic interface to initialize any type, for example assigning
#' age-composition data to a given fleet would be an example of initializing
#' a composition module.
#'
#' @inheritParams initialize_module
#' @param fleet_name A character specifying the name of the fleet for which
#'   composition data is initialized.
#' @param type A character specifying the composition type, where the default
#'   is `"AgeComp"`. At the moment, one can initialize `"AgeComp"` or
#'   `"LengthComp"` modules.
#' @return
#' The initialized composition module as an object.
#' @noRd
initialize_comp <- function(data,
                            fleet_name,
                            type = c("AgeComp", "LengthComp")) {
  # Edit this list if a new type is added
  # Set up the specifics for the given type.
  comp_types <- list(
    "AgeComp" = list(
      "name" = "age_comp",
      "comp_data_field" = "age_comp_data",
      "get_n_function" = get_n_ages,
      "comp_object" = AgeComp,
      "m_comp" = model_age_comp
    ),
    "LengthComp" = list(
      "name" = "length_comp",
      "comp_data_field" = "length_comp_data",
      "get_n_function" = get_n_lengths,
      "comp_object" = LengthComp,
      "m_comp" = model_length_comp
    )
  )

  # Ensures the user input matches the options provided,
  #   if not, then match.arg() throws an error
  type <- match.arg(type)
  # Select the row in comp_types that matches the user's type selection
  comp <- comp_types[[type]]

  # Check if the specified fleet exists in the data
  fleet_exists <- any(get_data(data)["name"] == fleet_name)
  if (!fleet_exists) {
    cli::cli_abort("Fleet `{fleet_name}` not found in the data object.")
  }

  get_function <- comp[["get_n_function"]]
  module <- methods::new(
    comp[["comp_object"]],
    get_n_years(data),
    get_function(data)
  )

  # Validate that the fleet's composition data is available
  comp_data <- comp[["m_comp"]](data, fleet_name)
  pretty_comp_name <- gsub("_comp", "-composition", comp[['name']])
  if (is.null(comp_data) || length(comp_data) == 0) {
    cli::cli_abort(c(
      "The {pretty_comp_name} data for fleet {.var {fleet_name}} is
      unavailable or empty."
    ))
  }

  model_data <- comp_data *
    get_data(data) |>
      dplyr::filter(
        name == fleet_name,
        type == comp[["name"]]
      ) |>
      dplyr::mutate(
        valid_n = ifelse(value == -999, 1, uncertainty)
      ) |>
      dplyr::pull(valid_n)

  if (length(model_data) != get_n_years(data) * get_function(data)) {
    bad_data_years <- get_data(data) |>
      dplyr::filter(
        name == fleet_name,
        type == comp[["name"]]
      ) |>
      dplyr::count(timing) |>
      dplyr::filter(n != get_function(data)) |>
      dplyr::pull(timing)

    cli::cli_abort(c(
      "The length of the `{comp[['name']]}`-composition data for fleet
      `{fleet_name}` does not match the expected dimensions.",
      i = "Expected length: {get_n_years(data) * get_function(data)}",
      i = "Actual length: {length(model_data)}",
      i = "Number of -999 values: {sum(model_data == -999)}",
      i = "Dates with invalid data: {bad_data_years}"
    ))
  }

  purrr::walk(
    seq_along(model_data),
    \(x) module[[comp[["comp_data_field"]]]]$set(x - 1, model_data[x])
  )

  return(module)
}

#' Initialize C++ modules via Rcpp for a FIMS model
#'
#' @description
#' This function uses information from a parameter data frame that stores the
#' model specifications and a`FIMSFrame` object that stores the data to
#' instantiate, i.e., create an instance of a class, the required C++ modules.
#' Several C++ modules are needed to run a FIMS model and the required modules
#' will be different for each model type. For example, for a catch-at-age
#' model one needs to instantiate recruitment, growth, and maturity modules and
#' at least one fleet and population module.
#'
#' @param parameters A tibble returned from [create_default_parameters()]. The
#'   tibble can be nested, i.e., contain a data column, or unnested, i.e.,
#'   `tidyr::unnest(create_default_parameters(), cols = "data")`. Regardless, it
#'   is the primary source of information for what is initialized. That is, if a
#'   fleet exists in the data but parameter information for how to specify
#'   selectivity for that fleet is not provided, then selectivity will not be
#'   initialized for that fleet.
#' @param data An S4 object with the `FIMSFrame` class, which is returned from
#'   [FIMSFrame()]. Passing the data is required because initialization of the
#'   modules requires passing the data and information regarding the uncertainty
#'   of that data, i.e., input sample sizes for the multinomial distribution.
#' @return
#' A list is returned with two elements, `parameters` and `model`. The list can
#' be passed to the `input` argument of [fit_fims()] to fit the model. The first
#' element of the list can also be passed to the `parameters` argument of
#' [TMB::MakeADFun()] if you wish to have more control over the model-fitting
#' process.
#' The model element of the returned list stores the instantiated C++ model
#' module, e.g., the results of `methods::new(CatchAtAge)` for a catch-at-age
#' model.
#' It is important that you only have one FIMS model initialized in your R
#' workspace at a time. Thus, after you initialize and fit the model, you should
#' run [clear()].
#' @export
#' @seealso
#' * [create_default_configurations()]
#' * [create_default_parameters()]
#' * [FIMSFrame()]
#' * [fit_fims()]
#' * [clear()]
#' @examples
#' \dontrun{
#' # Prepare data for FIMS model
#' data("data_big", package = "FIMS")
#' data_4_model <- FIMSFrame(data_big)
#' # Instantiate modules
#' parameters_list <- data_4_model |>
#'   create_default_configurations() |>
#'   create_default_parameters(data = data_4_model) |>
#'   initialize_fims(data = data_4_model)
#' clear()
#' }
initialize_fims <- function(parameters, data) {
  # Validate parameters input
  if (missing(parameters) || !tibble::is_tibble(parameters)) {
    cli::cli_abort("The {.var parameters} argument must be a tibble.")
  }

  # Check if parameters is a nested tibble. If so, unnest parameters
  if ("data" %in% names(parameters)) {
    parameters <- parameters |>
      tidyr::unnest(cols = c(data))
  }

  # Check if estimation_type is within "constant", "fixed_effect", "random_effect"
  # Validates supported estimation types to avoid errors later when
  #
  valid_estimation_types <- c("constant", "fixed_effects", "random_effects")
  invalid_estimation_types <- parameters |>
    dplyr::filter(!estimation_type %in% valid_estimation_types) |>
    dplyr::pull(estimation_type) |>
    unique() |>
    na.omit()

  if (length(invalid_estimation_types) > 0) {
    cli::cli_abort(c(
      "The `estimation_type` must be one of: {valid_estimation_types}.",
      i = "Invalid values found: {invalid_estimation_types}."
    ))
  }

  # Clear any previous FIMS settings
  clear()

  fleet_names <- parameters |>
    dplyr::pull(fleet_name) |>
    unique() |>
    na.omit()

  if (length(fleet_names) == 0) {
    cli::cli_abort(c(
      "No fleets found in the provided {.var parameters}."
    ))
  }

  # Initialize lists to store fleet-related objects
  fleet <- fleet_selectivity <-
    fleet_landings <- fleet_landings_distribution <-
    fleet_index <- fleet_index_distribution <-
    fleet_age_comp <- fleet_agecomp_distribution <-
    fleet_length_comp <- fleet_lengthcomp_distribution <-
    vector("list", length(fleet_names))

  for (i in seq_along(fleet_names)) {
    fleet_selectivity[[i]] <- initialize_selectivity(
      parameters = parameters,
      data = data,
      fleet_name = fleet_names[i]
    )

    fleet_module_ids <- c(
      selectivity = fleet_selectivity[[i]]$get_id()
    )

    fleet_types <- get_data(data) |>
      dplyr::filter(name == fleet_names[i]) |>
      dplyr::pull(type) |>
      unique()

    data_distribution_names_for_fleet_i <- parameters |>
      dplyr::filter(fleet_name == fleet_names[i] & distribution_type == "Data") |>
      dplyr::pull(module_type)

    # Initialize landings module if the data type includes "landings" and
    # if "Landings" exists in the data distribution specification
    if ("landings" %in% fleet_types &&
      "Landings" %in% data_distribution_names_for_fleet_i) {
      # Initialize landings module for the current fleet
      fleet_landings[[i]] <- initialize_landings(
        data = data,
        fleet_name = fleet_names[i]
      )

      # Add the module ID for the initialized landings to the list of fleet module IDs
      fleet_module_ids <- c(
        fleet_module_ids,
        c(landings = fleet_landings[[i]]$get_id())
      )
    }

    # Initialize index module if the data type includes "index" and
    # if "Index" exists in the data distribution specification
    if ("index" %in% fleet_types &&
      "Index" %in% data_distribution_names_for_fleet_i) {
      # Initialize index module for the current fleet
      fleet_index[[i]] <- initialize_index(
        data = data,
        fleet_name = fleet_names[i]
      )

      # Add the module ID for the initialized index to the list of fleet module IDs
      fleet_module_ids <- c(
        fleet_module_ids,
        c(index = fleet_index[[i]]$get_id())
      )
    }

    # Initialize age composition module if the data type includes "age_comp" and
    # if "AgeComp" exists in the data distribution specification
    if ("age_comp" %in% fleet_types &&
      "AgeComp" %in% data_distribution_names_for_fleet_i) {
      # Initialize age composition module for the current fleet
      fleet_age_comp[[i]] <- initialize_comp(
        data = data,
        fleet_name = fleet_names[i],
        type = "AgeComp"
      )

      # Add the module ID for the initialized age composition to the list of fleet module IDs
      fleet_module_ids <- c(
        fleet_module_ids,
        c(age_comp = fleet_age_comp[[i]]$get_id())
      )
    }

    # Initialize length composition module if the data type includes "length_comp" and
    # if "LengthComp" exists in the data distribution specification
    if ("length_comp" %in% fleet_types &&
      "LengthComp" %in% data_distribution_names_for_fleet_i) {
      # Initialize length composition module for the current fleet
      fleet_length_comp[[i]] <- initialize_comp(
        data = data,
        fleet_name = fleet_names[i],
        type = "LengthComp"
      )

      # Add the module ID for the initialized length composition to the list of fleet module IDs
      fleet_module_ids <- c(
        fleet_module_ids,
        c(length_comp = fleet_length_comp[[i]]$get_id())
      )
    }

    fleet[[i]] <- initialize_fleet(
      parameters = parameters,
      data = data,
      fleet_name = fleet_names[i],
      # TODO: need to remove linked_ids from the function and add module_id to the
      # parameters tibble
      linked_ids = fleet_module_ids
    )

    fleet_sd_input <- parameters |>
      dplyr::filter(fleet_name == fleet_names[i] & label == "log_sd") |>
      dplyr::mutate(
        label = "sd",
        value = exp(value)
      )

    if (length(fleet_sd_input) == 0) {
      cli::cli_abort(c(
        "Missing required inputs for `log_sd` in fleet `{fleet_name}`."
      ))
    }

    if ("index" %in% fleet_types &&
      "Index" %in% data_distribution_names_for_fleet_i) {
      fleet_index_distribution[[i]] <- initialize_data_distribution(
        module = fleet[[i]],
        # TODO: need to update family and match options from the distribution
        # column from the parameters tibble
        family = lognormal(link = "log"),
        sd = fleet_sd_input,
        data_type = "index"
      )
    }

    if ("landings" %in% fleet_types &&
      "Landings" %in% data_distribution_names_for_fleet_i) {
      fleet_landings_distribution[[i]] <- initialize_data_distribution(
        module = fleet[[i]],
        # TODO: need to update family and match options from the distribution
        # column from the parameters tibble
        family = lognormal(link = "log"),
        sd = fleet_sd_input,
        data_type = "landings"
      )
    }

    if ("age_comp" %in% fleet_types &&
      "AgeComp" %in% data_distribution_names_for_fleet_i) {
      fleet_agecomp_distribution[[i]] <- initialize_data_distribution(
        module = fleet[[i]],
        # TODO: need to update family and match options from the distribution
        # column from the parameters tibble
        family = multinomial(link = "logit"),
        data_type = "agecomp"
      )
    }

    if ("length_comp" %in% fleet_types &&
      "LengthComp" %in% data_distribution_names_for_fleet_i) {
      fleet_lengthcomp_distribution[[i]] <- initialize_data_distribution(
        module = fleet[[i]],
        # TODO: need to update family and match options from the distribution
        # column from the parameters tibble
        family = multinomial(link = "logit"),
        data_type = "lengthcomp"
      )
    }
  }

  # Recruitment
  # create new module in the recruitment class (specifically Beverton--Holt,
  # when there are other options, this would be where the option would be
  # chosen)
  recruitment <- initialize_recruitment(
    parameters = parameters,
    data = data
  )

  recruitment_process_input <- parameters |>
    dplyr::filter(module_name == "Recruitment" & distribution_type == "process")

  if (length(recruitment_process_input) == 0) {
    # TODO: need to revisit initialize_process_structure and add R tests
    recruitment_process <- initialize_process_structure(
      module = recruitment,
      par = "log_devs"
    )
  } else {
    pars <- recruitment_process_input |>
      dplyr::pull(distribution_link) |>
      unique()

    # Initialize_process_distribution for each par
    recruitment_distribution <- purrr::map(pars, function(par) {
      sd_input <- recruitment_process_input |>
        dplyr::filter(distribution_link == par & label == "log_sd")
      initialize_process_distribution(
        module = recruitment,
        par = par,
        # TODO: need to update family and match options from the distribution
        # column from the parameters tibble
        family = gaussian(),
        sd = sd_input,
        # TODO: need to remove is_random_effect and match options from the
        # estimation_type from the parameters tibble
        is_random_effect = FALSE
      )

      recruitment_process <- initialize_process_structure(
        module = recruitment,
        par = par
      )
    })
  }

  # Growth
  growth <- initialize_growth(
    parameters = parameters,
    data = data
  )

  # Maturity
  maturity <- initialize_maturity(
    parameters = parameters,
    data = data
  )

  population_module_ids <- c(
    recruitment = recruitment$get_id(),
    growth = growth$get_id(),
    maturity = maturity$get_id(),
    fleets = purrr::map(fleet, \(x) x$get_id())
  )

  # Population
  population <- initialize_population(
    parameters = parameters,
    data = data,
    # TODO: need to remove linked_ids from the function and add module_id to the
    # parameters tibble
    linked_ids = population_module_ids
  )

  # Set-up TMB
  # Hard code to be a catch-at-age model
  fims_model <- methods::new(CatchAtAge)
  fims_model$AddPopulation(population$get_id())

  CreateTMBModel()
  # Create parameter list from Rcpp modules
  parameter_list <- list(
    parameters = list(
      p = get_fixed(),
      re = get_random()
    ),
    model = fims_model
  )

  return(parameter_list)
}

#' Set parameter vector values based on module input
#'
#' @description
#' This function sets the parameter vector values in a module based on the
#' provided module input, including both initial values and estimation
#' information.
#' @param field A character string specifying the field name of the parameter
#'   vector to be updated.
#' @param module A module object in which the parameter vector is to be set.
#' @param module_input A list containing input parameters for the module,
#'   including value and estimation information for the parameter vector.
#' @return
#' Modified module object.
#' @noRd
set_param_vector <- function(field, module, module_input) {
  # Check if field_name is a non-empty character string
  if (missing(field) || !is.character(field) || nchar(field) == 0) {
    cli::cli_abort(c(
      "The {.var field} argument must be a non-empty character string."
    ))
  }

  # Check if module is a reference class
  if (!is(module, "refClass")) {
    cli::cli_abort(c(
      "The {.var module} argument must be a reference class created by
      {.fn methods::new}."
    ))
  }

  # Check if module_input is a list
  if (!tibble::is_tibble(module_input)) {
    cli::cli_abort("The {.var module_input} argument must be a tibble.")
  }

  # Extract the value of the parameter vector
  field_value <- module_input |>
    dplyr::filter(label == field) |>
    dplyr::pull(value)

  field_estimation_type <- module_input |>
    dplyr::filter(label == field) |>
    dplyr::pull(estimation_type)

  # Check if both value and estimation information are present
  if (length(field_value) == 0 || length(field_estimation_type) == 0) {
    cli::cli_abort(c(
      "Missing value or estimation_type information for {.var field}."
    ))
  }
  # Resize the field in the module
  module[[field]]$resize(length(field_value))

  # Assign each value to the corresponding position in the parameter vector
  for (i in seq_along(field_value)) {
    module[[field]][i][["value"]] <- field_value[i]
    module[[field]][i][["estimation_type"]]$set(field_estimation_type[i])
  }
}

# To remove the NOTE
# no visible binding for global variable
utils::globalVariables(c(
  "parameter_id", "module_name", "module_id", "label",
  "estimate", "estimate.x", "estimate.y",
  "initial", "initial.x", "initial.y",
  "derived_quantity_id",
  "distribution", "gradient",
  "log_like_cv",
  "module_type", "n", "type_id", "values",
  "module_name.x", "module_name.y",
  "module_id.x", "module_id.y",
  "module_id_init",
  "module_type.x", "module_type.y",
  "unique_id"
))

# Developers: ----

# This file defines the parent class of FIMSFit and its potential children. The
# class is an S4 class with accessors and validators but no setters. For more
# details on how to create an S4 class in FIMS please see R/fimsframe.R

# TODO: ----

# TODO: Fix "no metadata object found to revise superClass" in sdreportOrList
# TODO: Write more validity checks for FIMSFit
# TODO: Better document the return of [get_estimates()], i.e., columns
# TODO: Make a helper function to add lower and upper CI for users in estimates

# methods::setClass: ----

# Need to use an S3 class for the following S4 class
methods::setOldClass(Classes = "package_version")
methods::setOldClass(Classes = "difftime")
methods::setOldClass(Classes = "sdreport")
# Join sdreport and list into a class in case the sdreport is not created
methods::setClassUnion("sdreportOrList", members = c("sdreport", "list"))

methods::setClass(
  Class = "FIMSFit",
  slots = c(
    input = "list",
    obj = "list",
    opt = "list",
    max_gradient = "numeric",
    report = "list",
    sdreport = "sdreportOrList",
    number_of_parameters = "integer",
    timing = "difftime",
    version = "package_version",
    model_output = "character"
  )
)

# methods::setMethod: printers ----
# TODO: add `get_report`, `get_opt`, etc. to the list of available slots in show()?
methods::setMethod(
  f = "show",
  signature = "FIMSFit",
  definition = function(object) {
    cli::cli_inform(c(
      "i" = "The object is of the class FIMSFit v.{get_version(object)}",
      "i" = "The slots can be accessed using {.fn get_*} functions, e.g.,",
      "*" = "{.fn get_model_output}",
      "*" = "{.fn get_obj}",
      "*" = "{.fn get_version}",
      "i" = "The following slots are available: {methods::slotNames(object)}.",
      "i" = "Use {.fn print} to see a summary of the fit."
    ))
  }
)

methods::setMethod(
  f = "print",
  signature = "FIMSFit",
  definition = function(x) {
    rt <- as.numeric(x@timing[["time_total"]], units = "secs")
    ru <- "seconds"
    if (rt > 60 * 60 * 24) {
      rt <- rt / (60 * 60 * 24)
      ru <- "days"
    } else if (rt > 60 * 60) {
      rt <- rt / (60 * 60)
      ru <- "hours"
    } else if (rt > 60) {
      rt <- rt / 60
      ru <- "minutes"
    }

    number_of_parameters <- paste(
      names(x@number_of_parameters),
      x@number_of_parameters,
      sep = "="
    )
    total_parameters <- sum(x@number_of_parameters)
    all_parameters_info <- c(number_of_parameters, paste(
      "total",
      total_parameters,
      sep = "="
    ))
    div_digit <- cli::cli_div(theme = list(.val = list(digits = 5)))
    terminal_ssb <- sapply(
      x@report[["spawning_biomass"]],
      function(y) utils::tail(y, 1)
    )
    cli::cli_inform(c(
      "i" = "FIMS model version: {.val {x@version}}",
      "i" = "Total run time was {.val {rt}} {ru}",
      "i" = "Number of parameters: {all_parameters_info}",
      "i" = "Maximum gradient= {.val {x@max_gradient}}",
      "i" = "Negative log likelihood (NLL):",
      "*" = "Marginal NLL= {.val {x@opt$objective}}",
      "*" = "Total NLL= {.val {x@report$jnll}}",
      "i" = "Terminal SB= {.val {terminal_ssb}}"
    ))
    cli::cli_end(div_digit)
  }
)

# methods::setMethod: accessors ----

# Accessor functions for a FIMSFit object
# 1 methods::setGeneric() per slot but potentially >1 methods::setMethod() per methods::setGeneric()

#' Get a slot in a FIMSFit object
#'
#' There is an accessor function for each slot in the S4 class `FIMSFit`, where
#' the function is named `get_*()` and the star can be replaced with the slot
#' name, e.g., [get_input()]. These accessor functions are the preferred way
#' to access objects stored in the available slots.
#'
#' @param x Output returned from [fit_fims()].
#' @name get_FIMSFit
#' @seealso
#' * [fit_fims()]
#' * [create_default_parameters()]
NULL

#' @return
#' [get_input()] returns the list that was used to fit the FIMS model, which
#' is the returned object from [create_default_parameters()].
#' @export
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setGeneric("get_input", function(x) standardGeneric("get_input"))
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setMethod("get_input", "FIMSFit", function(x) x@input)

#' @return
#' [get_report()] returns the TMB report, where anything that is flagged as
#' reportable in the C++ code is returned.
#' @export
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setGeneric("get_report", function(x) standardGeneric("get_report"))
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setMethod("get_report", "FIMSFit", function(x) x@report)

#' @return
#' [get_obj()] returns the output from [TMB::MakeADFun()].
#' @export
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setGeneric("get_obj", function(x) standardGeneric("get_obj"))
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setMethod("get_obj", "FIMSFit", function(x) x@obj)

#' @return
#' [get_opt()] returns the output from [nlminb()], which is the minimizer used
#' in [fit_fims()].
#' @export
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setGeneric("get_opt", function(x) standardGeneric("get_opt"))
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setMethod("get_opt", "FIMSFit", function(x) x@opt)

#' @return
#' [get_max_gradient()] returns the maximum gradient found when optimizing the
#' model.
#' @export
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setGeneric("get_max_gradient", function(x) standardGeneric("get_max_gradient"))
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setMethod("get_max_gradient", "FIMSFit", function(x) x@max_gradient)

#' @return
#' [get_sdreport()] returns the list from [TMB::sdreport()].
#' @export
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setGeneric("get_sdreport", function(x) standardGeneric("get_sdreport"))
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setMethod("get_sdreport", "FIMSFit", function(x) x@sdreport)

#' @return
#' [get_estimates()] returns a tibble of parameter values and their
#' uncertainties from a fitted model.
#' @export
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setGeneric("get_estimates", function(x) standardGeneric("get_estimates"))
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setMethod(
  "get_estimates",
  "FIMSFit",
  function(x) {
    # Helper function
    add_unique_id <- function(data) {
      dplyr::group_by(data, label) |>
        dplyr::mutate(
          unique_id = paste(
            label,
            dplyr::if_else(
              is.na(parameter_id),
              seq_len(dplyr::n()),
              parameter_id
            ),
            sep = "_"
          )
        ) |>
        dplyr::ungroup()
    }
    # Extract the core TMB components (object, sdreport, optimization result)
    # from the fit object.
    obj <- get_obj(x)
    sdreport <- get_sdreport(x)
    opt <- get_opt(x)
    parameter_names <- get_obj(x)[["par"]] |>
      names()

    # Reshape the TMB output into a standardized data frame.
    # This serves as the "expected" result to compare against.
    tmb_output <- reshape_tmb_estimates(
      obj = obj,
      sdreport = sdreport,
      opt = opt,
      parameter_names = parameter_names
    ) |>
      add_unique_id()

    # Extract the model_output, which contains the JSON-like structure.
    model_output <- get_model_output(x)
    # Reshape the output from the JSON structure into a data frame.
    json_output <- reshape_json_estimates(model_output) |>
      add_unique_id()

    # Join the two outputs on parameter_id to compare and consolidate information.
    estimates <- dplyr::left_join(
      # There are more rows in json_estimates than tmb_estimates
      x = json_output,
      y = tmb_output |>
        dplyr::select(unique_id, uncertainty, log_like_cv, gradient),
      by = c("unique_id")
    ) |>
      dplyr::select(-unique_id) |>
      dplyr::relocate(uncertainty, .after = estimation_type)
  }
)

#' @return
#' [get_number_of_parameters()] returns a vector of integers specifying the
#' number of fixed-effect parameters and the number of random-effect parameters
#' in the model.
#' @export
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setGeneric(
  "get_number_of_parameters",
  function(x) standardGeneric("get_number_of_parameters")
)
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setMethod(
  "get_number_of_parameters",
  "FIMSFit",
  function(x) x@number_of_parameters
)

#' @return
#' [get_timing()] returns the amount of time it took to run the model in
#' seconds as a `difftime` object.
#' @export
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setGeneric("get_timing", function(x) standardGeneric("get_timing"))
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setMethod("get_timing", "FIMSFit", function(x) x@timing)

#' @return
#' [get_version()] returns the `package_version` of FIMS that was used to fit
#' the model.
#' @export
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setGeneric("get_version", function(x) standardGeneric("get_version"))
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setMethod("get_version", "FIMSFit", function(x) x@version)

#' @return
#' [get_model_output()] returns the finalized FIMS output as a JSON list.
#' @export
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setGeneric("get_model_output", function(x) standardGeneric("get_model_output"))
#' @rdname get_FIMSFit
#' @keywords fit_fims
methods::setMethod("get_model_output", "FIMSFit", function(x) x@model_output)

# methods::setValidity ----

methods::setValidity(
  Class = "FIMSFit",
  method = function(object) {
    errors <- character()

    # Check that obj is from TMB::MakeADFun()
    TMB_MakeADFun_names <- c(
      "par", "fn", "gr", "he", "hessian", "method", "retape", "env", "report",
      "simulate"
    )
    if (!setequal(names(object@obj), TMB_MakeADFun_names)) {
      errors <- c(
        errors,
        "obj must be a list returned from TMB::MakeADFun() but it does not
        appear to be so because it does not have the standard names."
      )
    }

    # Return
    if (length(errors) == 0) {
      return(TRUE)
    } else {
      return(errors)
    }
  }
)

# methods::setMethod: is.FIMSFit ----

#' Check if an object is of class FIMSFit
#'
#' @param x Returned list from [fit_fims()].
#' @keywords fit_fims
#' @export
is.FIMSFit <- function(x) {
  inherits(x, "FIMSFit")
}

# Constructors ----

#' Class constructors for class `FIMSFit` and associated child classes
#'
#' Create an object with the class of `FIMSFit` after running a FIMS model. This
#' is typically done within [fit_fims()] but it can be create manually by the
#' user if they have used their own bespoke code to fit a FIMS model.
#'
#' @inheritParams fit_fims
#' @param obj An object returned from [TMB::MakeADFun()].
#' @param opt An object returned from an optimizer, typically from
#'   [stats::nlminb()], used to fit a TMB model.
#' @param sdreport An object of the `sdreport` class as returned from
#'   [TMB::sdreport()].
#' @param timing A vector of at least length one, where all entries are of the
#'   `timediff` class and at least one is named "time_total". This information
#'   is available in [fit_fims()] and added to this argument internally but if
#'   you are a power user you can calculate the time it took to run your model
#'   by subtracting two [Sys.time()] objects.
#' @param version The version of FIMS that was used to optimize the model. If
#'   [fit_fims()] was not used to optimize the model, then the default is to
#'   use the current version of the package that is loaded.
#'
#' @return
#' An object with an S4 class of `FIMSFit` is returned. The object will have the
#' following slots:
#'   \describe{
#'     \item{\code{input}:}{
#'       A list containing the model setup in the same form it was passed.
#'     }
#'     \item{\code{obj}:}{
#'       A list returned from [TMB::MakeADFun()] in the same form it was passed.
#'     }
#'     \item{\code{opt}:}{
#'       A list containing the optimized model in the same form it was passed.
#'     }
#'     \item{\code{max_gradient}:}{
#'       The maximum gradient found when optimizing the model. The default is
#'       `NA`, which means that the model was not optimized.
#'     }
#'     \item{\code{report}:}{
#'       A list containing the model report from `obj[["report"]]()`.
#'     }
#'     \item{\code{sdreport}:}{
#'       An object with the `sdreport` class containing the output from
#'       `TMB::sdreport(obj)`.
#'     }
#'     \item{\code{timing}:}{
#'       The length of time it took to run the model if it was optimized.
#'     }
#'     \item{\code{version}:}{
#'       The package version of FIMS used to fit the model or at least the
#'       version used to create this output, which will not always be the same
#'       if you are running this function yourself.
#'     }
#'     \item{\code{model_output}:}{
#'       The FIMS model output as a JSON string.
#'     }
#'   }
#' @keywords fit_fims
#' @export
FIMSFit <- function(
  input,
  obj,
  opt = list(),
  sdreport = list(),
  timing = c("time_total" = as.difftime(0, units = "secs")),
  version = utils::packageVersion("FIMS")
) {
  # Determine the number of parameters
  n_total <- length(obj[["env"]][["last.par.best"]])
  n_fixed_effects <- length(obj[["par"]])
  n_random_effects <- length(obj[["env"]]$parList()[["re"]])
  number_of_parameters <- c(
    fixed_effects = n_fixed_effects,
    random_effects = n_random_effects
  )
  rm(n_total, n_fixed_effects, n_random_effects)

  # Calculate the maximum gradient
  max_gradient <- if (length(opt) > 0) {
    max(abs(obj[["gr"]](opt[["par"]])))
  } else {
    NA_real_
  }

  # Rename parameters instead of "p"
  parameter_names <- names(get_parameter_names(obj[["par"]]))
  names(obj[["par"]]) <- parameter_names
  random_effects_names <- names(get_random_names(obj[["env"]]$parList()[["re"]]))

  # Get the report
  report <- if (length(opt) == 0) {
    obj[["report"]](obj[["env"]][["last.par.best"]])
  } else {
    obj[["report"]]()
  }

  if (length(sdreport) > 0) {
    # rename the sdreport
    names(sdreport[["par.fixed"]]) <- parameter_names
    dimnames(sdreport[["cov.fixed"]]) <- list(parameter_names, parameter_names)
  }

  model_output <- input[["model"]]$get_output()

  fit <- methods::new(
    "FIMSFit",
    input = input,
    obj = obj,
    opt = opt,
    max_gradient = max_gradient,
    report = report,
    sdreport = sdreport,
    number_of_parameters = number_of_parameters,
    timing = timing,
    version = version,
    model_output = model_output
  )
  fit
}

#' Fit a FIMS model (BETA)
#'
#' @param input Input list as returned by [initialize_fims()].
#' @param get_sd A boolean specifying if the [TMB::sdreport()] should be
#'   calculated?
#' @param save_sd A logical, with the default `TRUE`, indicating whether the
#'   sdreport is returned in the output. If `FALSE`, the slot for the report
#'   will be empty.
#' @param number_of_loops A positive integer specifying the number of
#'   iterations of the optimizer that will be performed to improve the
#'   gradient. The default is three, leading to four total optimization steps.
#' @param optimize Optimize (TRUE, default) or (FALSE) build and return
#'   a list containing the obj and report slot.
#' @param number_of_newton_steps The number of Newton steps using the inverse
#'   Hessian to do after optimization. Not yet implemented.
#' @param control A list of optimizer settings passed to [stats::nlminb()]. The
#'   the default is a list of length three with `eval.max = 1000`,
#'   `iter.max = 10000`, and `trace = 0`.
#' @param filename Character string giving a file name to save the fitted
#'   object as an RDS object. Defaults to 'fit.RDS', and a value of NULL
#'   indicates not to save it. If specified, it must end in .RDS. The file is
#'   written to folder given by `input[["path"]]`. Not yet implemented.
#' @return
#' An object of class `FIMSFit` is returned, where the structure is the same
#' regardless if `optimize = TRUE` or not. Uncertainty information is only
#' included in the `estimates` slot if `get_sd = TRUE`.
#' @seealso
#' * [FIMSFit()]
#' @details This function is a beta version still and subject to change
#'   without warning.
#' @keywords fit_fims
#' @export
fit_fims <- function(input,
                     get_sd = TRUE,
                     save_sd = TRUE,
                     number_of_loops = 3,
                     optimize = TRUE,
                     number_of_newton_steps = 0,
                     control = list(
                       eval.max = 10000,
                       iter.max = 10000,
                       trace = 0
                     ),
                     filename = NULL) {
  # See issue 455 of sdmTMB to see what should be used.
  # https://github.com/pbs-assess/sdmTMB/issues/455
  # NOTE: When we add implementation for newton step we need to
  # review the above github issue to make sure we maintain continuity
  # between outputs as last.par may not equal last.par.best due to
  # the smallest newton gradient solution not matching the smallest
  # likelihood value. This can cause sanity issues in output reporting.
  if (number_of_newton_steps > 0) {
    cli::cli_abort("Newton steps not implemented yet.")
  }
  if (number_of_loops < 0) {
    cli::cli_abort("number_of_loops ({.par {number_of_loops}}) must be >= 0.")
  }
  # If the estimation_type of all parameters is constant, FIMS will abort if
  # optimize is set to TRUE
  if (optimize == TRUE & all(purrr::map_vec(input[["parameters"]], length) == 0)) {
    cli::cli_abort("FIMS must have at least one parameter to optimize.")
  }

  obj <- TMB::MakeADFun(
    data = list(),
    parameters = input$parameters,
    map = input$map,
    random = "re",
    DLL = "FIMS",
    silent = TRUE
  )
  if (!optimize) {
    initial_fit <- FIMSFit(
      input = input,
      obj = obj,
      timing = c("time_total" = as.difftime(0, units = "secs"))
    )
    return(initial_fit)
  }
  if (!is_fims_verbose()) {
    control$trace <- 0
  }
  ## optimize and compare
  cli::cli_inform(c("v" = "Starting optimization ..."))
  t0 <- Sys.time()
  opt <- with(
    obj,
    nlminb(
      start = par,
      objective = fn,
      gradient = gr,
      control = control
    )
  )
  maxgrad0 <- maxgrad <- max(abs(obj$gr(opt$par)))
  if (number_of_loops > 0) {
    cli::cli_inform(c(
      "i" = "Restarting optimizer {number_of_loops} times to improve gradient."
    ))
    for (ii in 1:number_of_loops) {
      # control$trace is reset to zero regardless of verbosity because the
      # differences in values printed out using control$trace will be
      # negligible between these different runs and is not worth printing
      control$trace <- 0
      opt <- with(
        obj,
        nlminb(
          start = opt[["par"]],
          objective = fn,
          gradient = gr,
          control = control
        )
      )
      maxgrad <- max(abs(obj[["gr"]](opt[["par"]])))
    }
    div_digit <- cli::cli_div(theme = list(.val = list(digits = 5)))
    cli::cli_inform(c(
      "i" = "Maximum gradient went from {.val {maxgrad0}} to
            {.val {maxgrad}} after {number_of_loops} steps."
    ))
    cli::cli_end(div_digit)
  }
  time_optimization <- Sys.time() - t0
  cli::cli_inform(c("v" = "Finished optimization"))
  set_fixed(opt$par)

  time_sdreport <- NA
  if (get_sd) {
    t2 <- Sys.time()
    sdreport <- TMB::sdreport(obj)
    cli::cli_inform(c("v" = "Finished sdreport"))
    time_sdreport <- Sys.time() - t2
  } else {
    sdreport <- list()
    time_sdreport <- as.difftime(0, units = "secs")
  }

  timing <- c(
    time_optimization = time_optimization,
    time_sdreport = time_sdreport,
    time_total = Sys.time() - t0
  )
  fit <- FIMSFit(
    input = input,
    obj = obj,
    opt = opt,
    sdreport = sdreport,
    timing = timing
  )
  print(fit)
  if (!is.null(filename)) {
    cli::cli_warn(c(
      "i" = "Saving output to file is not yet implemented."
    ))
    # saveRDS(fit, file=file.path(input[["path"]], filename))
  }
  return(fit)
}

# we create an as.list method for this new FIMSFit
methods::setMethod("as.list", signature(x = "FIMSFit"), function(x) {
  mapply(
    function(y) {
      # apply as.list if the slot is again an user-defined object
      # therefore, as.list gets applied recursively
      if (inherits(slot(x, y), "FIMSFit")) {
        as.list(slot(x, y))
      } else {
        # otherwise just return the slot
        slot(x, y)
      }
    },
    slotNames(class(x)),
    SIMPLIFY = FALSE
  )
})

# TODO: Document the names/items in each list that are returned

# To remove the WARNING
# no visible binding for global variable
utils::globalVariables(c(
  "distribution.x", "distribution.y",
  "distribution_link",
  "distribution_type.x", "distribution_type.y",
  "fleet_name",
  "model_family", "model_family.x", "model_family.y"
))

#' Create default parameters for a FIMS model
#'
#' @description
#' This function generates a Fisheries Integrated Modeling System (FIMS) model
#' configuration with detailed parameter specifications. This function takes a
#' high-level configuration `tibble` and generates the corresponding parameters
#' with default initial values and estimation settings required to build and run
#' the model.
#'
#' @details
#' The function processes the input `configurations` tibble, which defines the
#' modules for different model components (e.g., `"Selectivity"`, `"Recruitment"`).
#' For each module specified, it calls internal helper functions to create a
#' default set of parameters. For example, if a fleet's selectivity is configured
#' as `"Logistic"`, it generates initial values for `"inflection_point"` and
#' `"slope"`.
#'
#' @param configurations A tibble of model configurations. Typically created
#'   by [create_default_configurations()]. Users can modify this tibble
#'   to customize the model structure before generating default parameters.
#' @param data An S4 object. FIMS input data.
#' @return A `tibble` with default model parameters. The tibble has a nested
#'   structure with the following top-level columns.
#' \describe{
#'   \item{\code{model_family}:}{The specified model family (e.g.,
#'     "catch_at_age").}
#'   \item{\code{module_name}:}{The name of the FIMS module (e.g.,
#'     "Data", "Selectivity", "Recruitment", "Growth", "Maturity").}
#'   \item{\code{fleet_name}:}{The name of the fleet the module applies to. This
#'     will be `NA` for non-fleet-specific modules like "Recruitment".}
#'   \item{\code{data}:}{A list-column containing a `tibble` with detailed
#'     parameters. Unnesting this column reveals:
#'     \describe{
#'       \item{\code{module_type}:}{The specific type of the module (e.g.,
#'         "Logistic" for a "Selectivity" module).}
#'       \item{\code{label}:}{The name of the parameter (e.g., "inflection_point").}
#'       \item{\code{distribution_link}:}{The component the distribution module
#'         links to.}
#'       \item{\code{age}:}{The age the parameter applies to.}
#'       \item{\code{length}:}{The length bin the parameter applies to.}
#'       \item{\code{time}:}{The time step (i.e., year) the parameter applies to.}
#'       \item{\code{value}:}{The initial value of the parameter.}
#'       \item{\code{estimation_type}:}{The type of estimation (e.g.,
#'         "constant", "fixed_effects", "random_effects").}
#'       \item{\code{distribution_type}:}{The type of distribution (e.g., "Data",
#'         "process").}
#'       \item{\code{distribution}:}{The name of distribution (e.g.,
#'         "Dlnorm", `Dmultinom`).}
#'     }
#'   }
#' }
#' @export
#' @seealso
#' * [FIMSFrame()]
#' * [create_default_configurations()]
#' @examples
#' \dontrun{
#' # Load the example dataset and create a FIMS data frame
#' data("data_big")
#' fims_frame <- FIMSFrame(data_big)
#'
#' # Create default configurations
#' default_configurations <- create_default_configurations(fims_frame)
#'
#' # Create default parameters
#' default_parameters <- create_default_parameters(
#'   configurations = default_configurations,
#'   data = fims_frame
#' ) |>
#'   tidyr::unnest(cols = data)
#'
#' # Update selectivity parameters for survey1
#' updated_parameters <- default_parameters |>
#'   dplyr::rows_update(
#'     tibble::tibble(
#'       fleet_name = "survey1",
#'       label = c("inflection_point", "slope"),
#'       value = c(1.5, 2)
#'     ),
#'     by = c("fleet_name", "label")
#'   )
#'
#' # Do the same as above except, model fleet1 with double logistic selectivity
#' # To see required parameters for double logistic selectivity, run
#' # show(DoubleLogisticSelectivity)
#' parameters_with_double_logistic <- default_configurations |>
#'   tidyr::unnest(cols = data) |>
#'   dplyr::rows_update(
#'     tibble::tibble(
#'       module_name = "Selectivity",
#'       fleet_name = "fleet1",
#'       module_type = "DoubleLogistic"
#'     ),
#'     by = c("module_name", "fleet_name")
#'   ) |>
#'   create_default_parameters(
#'     data = fims_frame
#'   )
#' }
create_default_parameters <- function(
  configurations,
  data
) {
  # FIXME: use default values if there are no fleets info passed into the
  # function or a fleet is not present but it has data? Maybe we don't want the
  # latter because it could be that we want to drop a fleet from a model but we
  # don't want to alter the data?

  # Check if configurations is a nested tibble. If so, unnest configurations
  if ("data" %in% names(configurations)) {
    unnested_configurations <- tidyr::unnest(configurations, cols = data)
  } else {
    unnested_configurations <- configurations
  }

  # Create fleet parameters
  fleet_names <- unnested_configurations |>
    dplyr::pull(fleet_name) |>
    na.omit() |>
    unique()
  fleet_temp <- purrr::map(
    fleet_names,
    function(fleet_name_i) {
      create_default_fleet(
        unnested_configurations = unnested_configurations,
        current_fleet_name = fleet_name_i,
        data = data
      )
    }
  ) |>
    # bind_rows now directly takes the list of tibbles from map()
    dplyr::bind_rows()

  # Create recruitment parameters
  recruitment_temp <- create_default_recruitment(
    unnested_configurations = unnested_configurations,
    data = data
  )

  # Create maturity parameters
  maturity_temp <- create_default_maturity(
    unnested_configurations = unnested_configurations,
    data = data
  )

  # Create population parameters
  # Handle population parameters based on recruitment form
  log_rzero <- recruitment_temp |>
    dplyr::filter(label == "log_rzero") |>
    dplyr::pull(value)

  population_temp <- create_default_Population(
    unnested_configurations = unnested_configurations,
    data,
    log_rzero = log_rzero
  )

  # Compile temps
  temp <- dplyr::bind_rows(
    fleet_temp,
    recruitment_temp,
    maturity_temp,
    population_temp
  )
  # Merge with configuration_unnest
  expanded_configurations <- dplyr::full_join(
    temp,
    unnested_configurations,
    by = c("module_name", "fleet_name", "module_type", "distribution_link")
  ) |>
    dplyr::mutate(
      model_family = dplyr::coalesce(model_family.y, model_family.x),
      distribution_type = dplyr::coalesce(distribution_type.y, distribution_type.x),
      distribution = dplyr::coalesce(distribution.y, distribution.x)
    ) |>
    dplyr::select(-dplyr::ends_with(c(".x", ".y"))) |>
    tidyr::fill(model_family) |>
    dplyr::select(
      model_family, module_name, module_type, label, distribution_link, dplyr::everything()
    ) |>
    tidyr::nest(.by = c(model_family, module_name, fleet_name))
}

#' Create default parameters for a FIMS model
#' @description
#' This function creates a template for default parameters used in a Fisheries
#' Integrated Modeling System (FIMS) model. The template includes fields for
#' module name, module type, label, fleet name, population name, age, length,
#' time, value, estimation type, distribution type, and distribution.
#' @param n_parameters An integer specifying the number of parameters in the template.
#' @return
#' A tibble template for a FIMS model.
#' @noRd
#' @examples
#' FIMS:::create_default_parameters_template(n_parameters = 3)
create_default_parameters_template <- function(n_parameters = 1) {
  template <- tibble::tibble(
    model_family = NA_character_,
    module_name = NA_character_,
    module_type = NA_character_,
    label = NA_character_,
    distribution_link = NA_character_,
    fleet_name = NA_character_,
    age = NA_real_,
    length = NA_real_,
    time = NA_integer_,
    value = NA_real_,
    estimation_type = NA_character_,
    distribution_type = NA_character_,
    distribution = NA_character_
  ) |>
    dplyr::slice(rep(1, each = n_parameters))
}

#' Create default population parameters
#'
#' @description
#' This function sets up default parameters for a population module.
#' @details
#' The natural log of the initial numbers at age (`log_init_naa.value`) is set based on
#' unexploited recruitment and natural mortality.
#' @param unnested_configurations A tibble of model configurations. Typically created
#'   by the `create_default_configurations()`.
#' @param data An S4 object. FIMS input data.
#' @param log_rzero A numeric value representing the natural log of unexploited
#'   recruitment.
#' @return
#' A tibble of default population parameters, including initial numbers at
#' age and natural mortality rate.
#' @noRd
create_default_Population <- function(
  unnested_configurations,
  data,
  log_rzero
) {
  # Input checks
  # Check if log_rzero is numeric
  if (!is.numeric(log_rzero) || length(log_rzero) != 1) {
    local_bullets <- c(
      "i" = "{.var log_rzero} argument must be a single numeric value.",
      "x" = "{.var log_rzero} has a length of {length(log_rzero)}.",
      "x" = "{.var log_rzero} is of the class {class(log_rzero)}."
    )
    names(local_bullets)[2] <- ifelse(length(log_rzero) > 1, "x", "i")
    names(local_bullets)[3] <- ifelse(inherits(log_rzero, "numeric"), "i", "x")
    cli::cli_abort(local_bullets)
  }

  # Extract necessary values from data
  n_years <- get_n_years(data)
  n_ages <- get_n_ages(data)

  # Define age and year vectors needed for the rep() calls ===
  ages <- get_ages(data)
  years <- get_start_year(data):get_end_year(data)

  # Set natural mortality rate
  M_value <- 0.2

  # Calculate initial numbers at age based on log_rzero and M_value
  init_naa <- exp(log_rzero) * exp(-(get_ages(data) - 1) * M_value)
  init_naa[n_ages] <- init_naa[n_ages] / M_value # sum of infinite series

  # Create a list of default parameters
  default <- create_default_parameters_template(
    n_parameters = n_years * n_ages
  ) |>
    # Add the module type, label, value, and estimation type
    dplyr::mutate(
      label = "log_M",
      value = log(M_value),
      age = rep(ages, n_years),
      time = rep(years, each = n_ages),
      estimation_type = "constant"
    ) |>
    dplyr::add_row(
      label = "log_init_naa",
      age = get_ages(data),
      value = log(init_naa),
      estimation_type = "fixed_effects"
    ) |>
    dplyr::mutate(
      module_name = "Population"
    )
}

#' Create default logistic parameters
#'
#' @description
#' This function sets up default parameters for a logistic function. There are
#' two specified parameters, the inflection point and slope.
#' @return
#' A tibble containing the default logistic parameters, with inflection_point and
#' slope values and their estimation status.
#' @noRd
create_default_Logistic <- function() {
  # Create a template for default parameters
  default <- create_default_parameters_template(n_parameters = 2) |>
    # Add the module type, label, value, and estimation type
    dplyr::mutate(
      module_type = "Logistic",
      label = c("inflection_point", "slope"),
      value = c(2, 1),
      estimation_type = "fixed_effects"
    )
}

#' Create default double logistic parameters
#'
#' @description
#' This function sets up default parameters for a double logistic function.
#' There four specified parameters, two for the ascending and two for the
#' descending inflection points and slopes.
#' @return
#' A tibble containing the default double logistic parameters,
#' inflection_point_asc, slope_asc, inflection_point_desc, and slope_desc
#' values and their estimation status.
#' @noRd
create_default_DoubleLogistic <- function(module_name = NA_character_) {
  default <- create_default_parameters_template(n_parameters = 4) |>
    dplyr::mutate(
      module_name = !!module_name,
      module_type = "DoubleLogistic",
      label = c("inflection_point_asc", "slope_asc", "inflection_point_desc", "slope_desc"),
      # TODO: Determine if inflection_point_desc should really be 4?
      value = c(2, 1, 4, 1),
      estimation_type = "fixed_effects"
    )
}

#' Create default selectivity parameters
#'
#' @description
#' This function sets up default parameters for a selectivity module.
#' @param form A string specifying the desired form of selectivity. Allowable
#'   forms include `r toString(formals(create_default_selectivity)[["form"]])`
#'   and the default is
#'   `r toString(formals(create_default_selectivity)[["form"]][1])`.
#' @return
#' A tibble is returned with the default parameter values for the specified form
#' of selectivity.
#' @noRd
create_default_selectivity <- function(
  form = c("Logistic", "DoubleLogistic")
) {
  # Input checks
  form <- rlang::arg_match(form)
  # NOTE: All new forms of selectivity must be placed in the vector of default
  # arguments for `form` and their methods but be placed below in the call to
  # `switch`
  default <- switch(form,
    "Logistic" = create_default_Logistic(),
    "DoubleLogistic" = create_default_DoubleLogistic()
  ) |>
    dplyr::mutate(
      module_name = "Selectivity"
    )
}

#' Create default fleet parameters
#'
#' @description
#' This function sets up default parameters for a fleet module. It compiles
#' selectivity parameters along with distributions for each type of data that
#' are present for the given fleet.
#'
#' @param unnested_configurations A tibble of model configurations. Typically
#'   created by the `create_default_configurations()`.
#' @param fleet_name A character. Name of the fleet.
#' @param data An S4 object. FIMS input data.
#' @return
#' A tibble with default parameters for the fleet.
#' @noRd
create_default_fleet <- function(unnested_configurations,
                                 current_fleet_name,
                                 data) {
  # Input checks
  if (length(current_fleet_name) > 1) {
    cli::cli_abort(c(
      "i" = "{.var current_fleet_name} should have a length of 1.",
      "x" = "{.var current_fleet_name} has a length of {length(current_fleet_name)}."
    ))
  }
  if (!inherits(current_fleet_name, "character")) {
    cli::cli_abort(c(
      "i" = "{.var current_fleet_name} should be a string.",
      "x" = "{.var current_fleet_name} is a {class(current_fleet_name)}."
    ))
  }

  # Create default selectivity parameters
  selectivity_form <- unnested_configurations |>
    dplyr::filter(fleet_name == current_fleet_name & module_name == "Selectivity") |>
    dplyr::pull(module_type)

  selectivity_default <- create_default_selectivity(
    form = selectivity_form
  ) |>
    # Add fleet name
    dplyr::mutate(
      fleet_name = current_fleet_name
    )

  # Get types of data for this fleet from the data object
  data_types_present <- get_data(data) |>
    dplyr::filter(name == current_fleet_name) |>
    dplyr::pull(type) |>
    unique()

  # Get data likelihood distributions assigned for this fleet
  distribution_names_for_fleet <- unnested_configurations |>
    dplyr::filter(fleet_name == current_fleet_name & module_name == "Data") |>
    dplyr::pull(module_type)

  # Determine default fleet parameters based on types of data present
  if ("index" %in% data_types_present &&
    "Index" %in% distribution_names_for_fleet) {
    fleet_index <- get_data(data) |>
      dplyr::filter(type == "index" & name == current_fleet_name) |>
      dplyr::rename(time = timing)

    q_default <- create_default_parameters_template(n_parameters = 1) |>
      dplyr::mutate(
        module_name = "Fleet",
        label = "log_q",
        fleet_name = current_fleet_name,
        value = 0,
        estimation_type = "fixed_effects"
      )

    index_distribution <- unnested_configurations |>
      dplyr::filter(
        fleet_name == current_fleet_name & module_name == "Data" & module_type == "Index"
      ) |>
      dplyr::pull(distribution)

    index_uncertainty <- get_data(data) |>
      dplyr::filter(name == current_fleet_name, type %in% c("index")) |>
      dplyr::arrange(dplyr::desc(type)) |>
      dplyr::pull(uncertainty)

    index_distribution_default <- switch(index_distribution,
      "Dnorm" = create_default_DnormDistribution(
        value = index_uncertainty,
        input_type = "data",
        data = data
      ),
      "Dlnorm" = create_default_DlnormDistribution(
        value = index_uncertainty,
        input_type = "data",
        data = data
      )
    ) |>
      dplyr::mutate(
        module_name = "Data",
        module_type = "Index",
        distribution_link = "Index",
        fleet_name = current_fleet_name,
        time = fleet_index[["time"]]
      )
  } else {
    q_default <- create_default_parameters_template(n_parameters = 1) |>
      dplyr::mutate(
        module_name = "Fleet",
        label = "log_q",
        fleet_name = current_fleet_name,
        value = 0,
        estimation_type = "constant"
      )
    index_distribution_default <- NULL
  }

  if ("landings" %in% data_types_present &&
    "Landings" %in% distribution_names_for_fleet) {
    fleet_landings <- get_data(data) |>
      dplyr::filter(type == "landings" & name == current_fleet_name) |>
      dplyr::rename(time = timing)

    log_Fmort_default <- create_default_parameters_template(
      n_parameters = get_n_years(data)
    ) |>
      dplyr::mutate(
        module_name = "Fleet",
        label = "log_Fmort",
        fleet_name = current_fleet_name,
        time = get_start_year(data):get_end_year(data),
        value = -3,
        estimation_type = "fixed_effects"
      )

    landings_distribution <- unnested_configurations |>
      dplyr::filter(fleet_name == current_fleet_name & module_name == "Data" & module_type == "Landings") |>
      dplyr::pull(distribution)

    landings_uncertainty <- get_data(data) |>
      dplyr::filter(name == current_fleet_name, type %in% c("landings")) |>
      dplyr::arrange(dplyr::desc(type)) |>
      dplyr::pull(uncertainty)

    landings_distribution_default <- switch(landings_distribution,
      "Dnorm" = create_default_DnormDistribution(
        value = landings_uncertainty,
        input_type = "data",
        data = data
      ),
      "Dlnorm" = create_default_DlnormDistribution(
        value = landings_uncertainty,
        input_type = "data",
        data = data
      )
    ) |>
      dplyr::mutate(
        module_name = "Data",
        module_type = "Landings",
        distribution_link = "Landings",
        fleet_name = current_fleet_name,
        time = fleet_landings[["time"]]
      )
  } else {
    fleet_index <- get_data(data) |>
      dplyr::filter(type == "index" & name == current_fleet_name)

    log_Fmort_default <- create_default_parameters_template(
      n_parameters = get_n_years(data)
    ) |>
      dplyr::mutate(
        module_name = "Fleet",
        label = "log_Fmort",
        fleet_name = current_fleet_name,
        time = get_start_year(data):get_end_year(data),
        value = -200,
        estimation_type = "constant"
      )

    landings_distribution_default <- NULL
  }

  # Compile all default parameters into a single list
  default <- dplyr::bind_rows(
    selectivity_default,
    q_default,
    log_Fmort_default,
    index_distribution_default,
    landings_distribution_default
  )
}

#' Create default maturity parameters
#'
#' @description
#' This function sets up default parameters for a maturity module.
#' @param form A string specifying the form of maturity (e.g.,
#' `"Logistic"`).
#' @return
#' A tibble containing the default maturity parameters.
#' @noRd
create_default_maturity <- function(
  unnested_configurations,
  data
) {
  # Input checks
  available_forms <- c("Logistic")
  form <- unnested_configurations |>
    dplyr::filter(module_name == "Maturity") |>
    dplyr::pull(module_type)
  if (!form %in% available_forms) {
    cli::cli_abort(c(
      "Invalid `module_type`` for Maturity: {.var {form}}",
      "i" = "Valid options include: {.var {available_forms}}"
    ))
  }

  # NOTE: All new forms of maturity must be placed in the vector of default
  # arguments for `form` and their methods but be placed below in the call to
  # `switch`
  default <- switch(form,
    "Logistic" = create_default_Logistic()
  ) |>
    # We don't have an option to input maturity data into FIMS, so the maturity
    # parameters aren't really estimable. The parameters should be constant for now.
    # See more details from https://github.com/orgs/NOAA-FIMS/discussions/944.
    dplyr::mutate(
      estimation_type = "constant",
      module_name = "Maturity"
    )
}

#' Create default Beverton--Holt recruitment parameters
#'
#' @description
#' This function sets up default parameters for a Beverton--Holt recruitment
#' relationship. Parameters include the natural log of unfished recruitment,
#' the logit transformation of the slope of the stock--recruitment curve to
#' keep it between zero and one, and the time series of stock--recruitment
#' deviations on the natural log scale.
#' @param data An S4 object. FIMS input data.
#' @return
#' A tibble containing default recruitment parameters.
#' @noRd
create_default_BevertonHoltRecruitment <- function(data) {
  # Create default parameters for Beverton--Holt recruitment
  log_rzero <- create_default_parameters_template(
    n_parameters = 1
  ) |>
    dplyr::mutate(
      label = "log_rzero",
      value = log(1e+06),
      estimation_type = "fixed_effects"
    )
  logit_steep <- create_default_parameters_template(
    n_parameters = 1
  ) |>
    dplyr::mutate(
      label = "logit_steep",
      value = -log(1.0 - 0.75) + log(0.75 - 0.2),
      estimation_type = "constant"
    )

  # TODO: Revisit the settings for log_r. Do we must set up log_r when
  # it is not random effect parameters?
  log_r <- create_default_parameters_template(
    n_parameters = get_n_years(data) - 1
  ) |>
    dplyr::mutate(
      # TODO: should this be LogRecDev to match output?
      label = "log_r",
      value = 0.0,
      time = (get_start_year(data) + 1):get_end_year(data),
      estimation_type = "constant"
    )

  log_devs <- create_default_parameters_template(
    n_parameters = get_n_years(data) - 1
  ) |>
    dplyr::mutate(
      # TODO: should this be LogRecDev to match output?
      label = "log_devs",
      value = 0.0,
      time = (get_start_year(data) + 1):get_end_year(data),
      estimation_type = "random_effects"
    )

  expected_recruitment <- create_default_parameters_template(
    n_parameters = get_n_years(data) + 1
  ) |>
    dplyr::mutate(
      label = "log_expected_recruitment",
      value = 0.0,
      estimation_type = "constant"
    )

  default <- dplyr::bind_rows(
    log_rzero,
    logit_steep,
    log_r,
    log_devs,
    expected_recruitment
  ) |>
    dplyr::mutate(
      module_name = "Recruitment",
      module_type = "BevertonHolt"
    )
}

#' Create default DnormDistribution parameters
#'
#' @description
#' This function sets up default parameters to calculate the density of a
#' normal distribution, i.e., `DnormDistribution`, module.
#' @param value A real number that is passed to `log_sd`. The default value is
#'   `0.1`.
#' @param data An S4 object. FIMS input data.
#' @param input_type A string specifying the input type. The available options
#'   are
#'   `r toString(formals(create_default_DnormDistribution)[["input_type"]])`.
#'   The default is
#'   `r toString(formals(create_default_DnormDistribution)[["input_type"]][1])`.
#' @return
#' A tibble of default parameters for Dnorm distribution.
#' @noRd
create_default_DnormDistribution <- function(
  value = 0.1,
  data,
  input_type = c("data", "process", "prior")
) {
  # Input checks
  input_type <- rlang::arg_match(input_type)

  # Create default parameters
  default <- create_default_parameters_template(
    n_parameters = length(value)
  ) |>
    # Add the module type and label
    dplyr::mutate(
      label = "log_sd",
      value = !!value,
      estimation_type = "constant",
      distribution_type = input_type,
      distribution = "Dnorm"
    )

  # If input_type is 'process', add additional parameters
  if (input_type == "process" | input_type == "prior") {
    new_params <- create_default_parameters_template(
      n_parameters = length(value)
    ) |>
      dplyr::mutate(label = "observed_values", value = 0) |>
      dplyr::add_row(
        label = "expected_values",
        value = rep(0, length(value))
      ) |>
      dplyr::mutate(
        estimation_type = "constant",
        distribution_type = input_type,
        distribution = "Dnorm"
      )

    default <- dplyr::bind_rows(
      default,
      new_params
    )
  }
}

#' Create default DlnormDistribution parameters
#'
#' @description
#' This function sets up default parameters to calculate the density of a
#' log-normal distribution, i.e., `DlnormDistribution`, module.
#' @param value Default value for `log_sd`.
#' @param data An S4 object. FIMS input data.
#' @param input_type A string specifying the input type. The available options
#'   are
#'   `r toString(formals(create_default_DlnormDistribution)[["input_type"]])`.
#'   The default is
#'   `r toString(formals(create_default_DlnormDistribution)[["input_type"]][1])`.
#' @return
#' A tibble of default parameters for Dlnorm distribution.
#' @noRd
create_default_DlnormDistribution <- function(
  value = 0.1,
  data,
  input_type = c("data", "process")
) {
  # Input checks
  # TODO: Determine if value can be a vector?
  if (!is.numeric(value) || any(value <= 0, na.rm = TRUE)) {
    cli::cli_abort(c(
      "i" = "Inputs to {.var value} must be positive and numeric.",
      "x" = "{.var value} is {.var {value}}."
    ))
  }
  input_type <- rlang::arg_match(input_type)

  log_value <- log(value)
  # Create the default list with log standard deviation
  default <- create_default_parameters_template(
    n_parameters = get_n_years(data)
  ) |>
    # Add the module label and value
    dplyr::mutate(
      label = "log_sd",
      value = log_value
    )

  # Add additional parameters if input_type is "process"
  if (input_type == "process") {
    default <- default |>
      dplyr::add_row(
        label = "observed_values",
        value = rep(0, get_n_years(data))
      )
  }

  default <- default |>
    dplyr::mutate(
      estimation_type = "constant",
      distribution_type = input_type,
      distribution = "Dlnorm"
    )
  return(default)
}

#' Create default recruitment parameters
#'
#' @description
#' This function sets up default parameters for a recruitment module.
#'
#' @param unnested_configurations A tibble of model configurations. Typically
#'   created by the `create_default_configurations()`.
#' @param data An S4 object. FIMS input data.
#' @return
#' A tibble with the default parameters for recruitment.
#' @noRd
create_default_recruitment <- function(
  unnested_configurations,
  data
) {
  # Input checks
  available_forms <- c("BevertonHolt")
  form <- unnested_configurations |>
    dplyr::filter(module_name == "Recruitment") |>
    dplyr::pull(module_type)
  if (!form %in% available_forms) {
    cli::cli_abort(c(
      "Invalid `module_type` for Recruitment: {.var {form}}",
      "i" = "Valid options include: {.var {available_forms}}"
    ))
  }
  # Create default parameters based on the recruitment form
  # NOTE: All new forms of recruitment must be placed in the vector of default
  # arguments for `form` and their methods but be placed below in the call to
  # `switch`
  form_default <- switch(form,
    "BevertonHolt" = create_default_BevertonHoltRecruitment(data)
  )

  distribution_input <- unnested_configurations |>
    dplyr::filter(module_name == "Recruitment")

  if (!is.null(distribution_input[["distribution"]])) {
    distribution_default <- switch(distribution_input[["distribution"]],
      "Dnorm" = create_default_DnormDistribution(
        data = data,
        input_type = "process"
      )
    )

    distribution_link <- distribution_input[["distribution_link"]]
    if (distribution_link == "log_devs") {
      distribution_default <- distribution_default |>
        dplyr::mutate(
          distribution_link = !!distribution_link
        )

      expanded_rows <- distribution_default |>
        dplyr::filter(label %in% c("observed_values", "expected_values")) |>
        # Create all combinations of the original rows and years
        tidyr::expand_grid(year = (get_start_year(data) + 1):get_end_year(data)) |>
        dplyr::mutate(
          time = year
        ) |>
        dplyr::select(-year)

      distribution_default <- distribution_default |>
        dplyr::filter(label == "log_sd") |>
        dplyr::bind_rows(expanded_rows)
    }
  }

  default <- dplyr::bind_rows(form_default, distribution_default) |>
    tidyr::fill(module_name, module_type)
}

#' Validity checks for distributions
#'
#' This function checks the validity of arguments passed to functions that
#' relate to distributions within the Fisheries Integrated Modeling System
#' (FIMS). This function is designed to fail early only once, otherwise it goes
#' through many checks before reporting the results in an attempt to give the
#' user the most information possible. If it were to fail on every mistake,
#' then the user might have to iterate through multiple changes to their input
#' values. Sometimes, their mistakes might take quite a bit of time to make it
#' to this function or worse they might be running things on the cloud and not
#' have immediate access to the report. Therefore, we feel that providing the
#' most information possible is the best way forward.
#'
#' @param args A named list of input arguments that must contain at least
#'   `family` and `sd`. `data_type` is only needed for some upstream functions.
#' @seealso
#' This function is used in the following functions:
#' * [initialize_data_distribution()]
#' * [initialize_process_distribution()]
#' @noRd
#' @return
#' If successful, `TRUE` is invisibly returned. If unsuccessful,
#' [cli::cli_abort()] is used to return the relevant error messages.
check_distribution_validity <- function(args) {
  # Separate objects from args
  family <- args[["family"]]
  sd <- args[["sd"]]
  # Optional argument data_type
  data_type <- args[["data_type"]]
  check_present <- purrr::map_vec(list("family" = family, "sd" = sd), is.null)

  # Set up global rules
  # FIXME: Move this to a data item in the package so it can be used everywhere
  # Could do a call to all data objects in the package and get unique types that
  # are available
  data_type_names <- c("landings", "index", "agecomp", "lengthcomp")
  if (is.null(data_type)) {
    available_distributions <- c("lognormal", "gaussian")
  } else {
    available_distributions <- switch(
      EXPR = ifelse(grepl("comp", data_type), "composition", data_type),
      "landings" = c("lognormal", "gaussian"),
      "index" = c("lognormal", "gaussian"),
      "composition" = c("multinomial"),
      "unavailable data type"
    )
  }
  elements_of_sd <- c("value", "estimation_type")

  # Start a bulleted list of errors and add to it in each if statement
  abort_bullets <- c(
    " " = "The following errors were found in the input argument {.var args}."
  )
  if (any(check_present)) {
    bad <- names(check_present[unlist(check_present)])
    abort_bullets <- c(
      abort_bullets,
      "x" = "{.var {bad}} {cli::qty(length(bad))} {?is/are} missing from
             {.var args}."
    )
    # Abort early because not all of the necessary items were in args
    cli::cli_abort(abort_bullets)
  }

  # Checks related to the family class
  if (!inherits(family, "family")) {
    abort_bullets <- c(
      abort_bullets,
      "x" = "The class of {.var family} is incorrect.",
      "i" = "{.var family} should be an object of class {.var family},
             e.g., `family = gaussian()`, instead of {class(family)}."
    )
  } else {
    if (
      !(family[["family"]] %in% available_distributions) ||
        "unavailable data type" %in% available_distributions
    ) {
      ifelse_type <- ifelse(
        is.null(data_type),
        "distribution",
        paste(data_type, "data")
      )
      abort_bullets <- c(
        abort_bullets,
        "x" = "FIMS currently does not allow the family to be
              {.code {family[['family']]}}.",
        "i" = "The families available for this {ifelse_type} are
              {.code {available_distributions}}."
      )
    }
  }

  # Checks related to the type of data
  if (!is.null(data_type)) {
    if (!(data_type %in% data_type_names)) {
      abort_bullets <- c(
        abort_bullets,
        "x" = "The specified {.var data_type} of {.var {data_type}} is not
               available.",
        "i" = "Allowed values for {.var data_type} are
               {.code {data_type_names}}."
      )
    }
  }

  # Checks related to standard deviation
  # Check if sd has both elements and if yes, then go onto the else statement
  # for major checks
  if (!all(elements_of_sd %in% names(sd))) {
    abort_bullets <- c(
      abort_bullets,
      "x" = "{.var {elements_of_sd}} need to be present in sd.",
      "i" = "Only {.code {names(sd)}} {cli::qty(length(sd))} {?is/are} present."
    )
  } else {
    if (!all(sd[["value"]] > 0, na.rm = TRUE)) {
      abort_bullets <- c(
        abort_bullets,
        "x" = "Values passed to {.var sd} are out of bounds.",
        "i" = "Values passed to {.var sd} {cli::qty(length(sd[['value']]))}
               {?is/are} {.code {sd[['value']]}}.",
        "i" = "All standard deviation (sd) values need to be positive."
      )
    }
    if (
      length(sd[["estimation_type"]]) > 1 &&
        length(sd[["value"]]) != length(sd[["estimation_type"]])
    ) {
      sd_length <- length(sd[["value"]])
      est_length <- length(sd[["estimation_type"]])
      abort_bullets <- c(
        abort_bullets,
        "x" = "The sizes of {.var value} and {.var estimation_type} within {.var sd}
               must match if more than one value is specified for the latter.",
        "i" = "The length of {.var sd[['value']]} is {.code {sd_length}}.",
        "i" = "The length of {.var sd[['estimation_type']]} is
               {.code {est_length}}."
      )
    }
  }

  # Check dimensions for data distributions: sd must be either length 1 (scalar)
  # or match data length when data_type is landings or index
  if (!is.null(data_type) && !is.null(args[["module"]])) {
    module <- args[["module"]]
    if (data_type == "landings" | data_type == "index") {
      n_obs <- module$n_years$get()

      if (length(sd[["value"]]) > 1 && length(sd[["value"]]) != n_obs) {
        abort_bullets <- c(
          abort_bullets,
          "x" = "The size of {.var log_sd} does not match the size of observed data for {data_type}.",
          "i" = "The {.var log_sd} vector is of size {length(sd[['value']])}.",
          "i" = "The observed {data_type} data vector is of size {n_obs}.",
          "i" = "Either provide a single {.var log_sd} value (scalar) or a vector matching the data length."
        )
      }
    }
  }

  # Return error messages if more than just the default is present
  if (length(abort_bullets) == 1) {
    invisible(TRUE)
  } else {
    cli::cli_abort(abort_bullets)
  }
}

#' Return name of expected value
#'
#' The combination of data type, family, and link lead to a specific name for
#' the expected value within the code base. This function looks at the
#' combination of these three objects and specifies the appropriate string for
#' its name going forward.
#' @inheritParams initialize_data_distribution
#' @noRd
#' @return
#' A string specifying the name of the expected value.
#'
get_expected_name <- function(family, data_type) {
  # TODO: Think about if the name of the expected value should change based on
  # the link or if it should stay the same? Keeping track of different names in
  # the code base might be too complex for the output as well
  family_string <- family[["family"]]
  link_string <- family[["link"]]
  expected_name <- dplyr::case_when(
    data_type == "landings" &&
      grepl("lognormal|gaussian", family_string) &&
      link_string == "log" ~ "log_landings_expected",
    data_type == "landings" &&
      grepl("lognormal|gaussian", family_string) &&
      link_string == "identity" ~ "landings_expected",
    data_type == "index" &&
      grepl("lognormal|gaussian", family_string) &&
      link_string == "log" ~ "log_index_expected",
    data_type == "index" &&
      grepl("lognormal|gaussian", family_string) &&
      link_string == "identity" ~ "index_expected",
    grepl("agecomp", data_type) ~ "agecomp_proportion",
    grepl("lengthcomp", data_type) ~ "lengthcomp_proportion",
  )
  # Check combination of entries was okay and led to valid name
  if (is.na(expected_name)) {
    cli::cli_abort(c(
      "x" = "The combination of data type, family, and link are incompatible in
             some way.",
      "i" = "{.var data_type} is {.var {data_type}}.",
      "i" = "The family is {.var {family_string}}.",
      "i" = "The link is {.var {link_string}}."
    ))
  }
  return(expected_name)
}

#' Set up a new distribution for a data type or a process
#'
#' Use [methods::new()] to set up a distribution within an existing module with
#' the necessary linkages between the two. For example, a fleet module will need
#' a distributional assumption for parts of the data associated with it, which
#' requires the use of `initialize_data_distribution()`, and a recruitment
#' module, like the Beverton--Holt stock--recruit relationship, will need a
#' distribution associated with the recruitment deviations, which requires
#' `initialize_process_distribution()`.
#' @param module An identifier to a C++ fleet module that is linked to the data
#'   of interest.
#' @param family A description of the error distribution and link function to
#'   be used in the model. The argument takes a family class, e.g.,
#'   `stats::gaussian(link = "identity")`.
#' @param sd A list of length two. The first entry is named `"value"` and it
#'   stores the initial values (scalar or vector) for the relevant standard
#'   deviations. The default is `value = 1`. The second entry is named
#'  `"estimation_type"` and it stores a vector of booleans (default = "constant") is a
#'   string indicating whether or not standard deviation is estimated as a fixed effect
#'   or held constant. If `"value"` is a vector and `"estimation_type"` is a scalar,
#'   the single value specified `"estimation_type"` value will be repeated to match the length of
#'   `value`. Otherwise, the dimensions of the two must match.
#' @param data_type A string specifying the type of data that the
#'   distribution will be fit to. Allowable types include
#'   `r toString(formals(initialize_data_distribution)[["data_type"]])`
#'   and the default is
#'   `r toString(formals(initialize_data_distribution)[["data_type"]][1])`.
#' @param par A string specifying the parameter name the distribution applies
#'   to. Parameters must be members of the specified module. Use
#'   `methods::show(module)` to obtain names of parameters within the module.
#' @param is_random_effect A boolean indicating whether or not the process is
#'   estimated as a random effect.
#' @return
#' A reference class. is returned. Use [methods::show()] to view the various
#' Rcpp class fields, methods, and documentation.
#' @keywords distribution
#' @export
#' @examples
#' \dontrun{
#' # Set up a new data distribution
#' n_years <- 30
#' # Create a new fleet module
#' fleet <- methods::new(Fleet)
#' # Create a distribution for the fleet module
#' fleet_distribution <- initialize_data_distribution(
#'   module = fishing_fleet,
#'   family = lognormal(link = "log"),
#'   sd = list(
#'     value = rep(sqrt(log(0.01^2 + 1)), n_years),
#'     estimation_type = rep("constant", n_years) # Could also be a single "constant"
#'   ),
#'   data_type = "index"
#' )
#'
#' # Set up a new process distribution
#' # Create a new recruitment module
#' recruitment <- methods::new(BevertonHoltRecruitment)
#' # view parameter names of the recruitment module
#' methods::show(BevertonHoltRecruitment)
#' # Create a distribution for the recruitment module
#' recruitment_distribution <- initialize_process_distribution(
#'   module = recruitment,
#'   par = "log_devs",
#'   family = gaussian(),
#'   sd = list(value = 0.4, estimation_type = "constant"),
#'   is_random_effect = FALSE
#' )
#' }
initialize_data_distribution <- function(
  module,
  family = NULL,
  # Create a tibble with value and estimation_type column for sd
  sd = tibble::tibble(
    value = 1,
    estimation_type = "constant"
  ),
  # FIXME: Move this argument to second to match where par is in
  # initialize_process_distribution
  data_type = c("landings", "index", "agecomp", "lengthcomp")
) {
  data_type <- rlang::arg_match(data_type)
  # FIXME: Make the available families a data object
  # Could also make the matrix of distributions available per type as a
  # data frame where the check could use the stored object.

  # validity check on user input
  args <- list(
    family = family,
    sd = sd,
    data_type = data_type,
    module = module
  )
  check_distribution_validity(args)

  # assign name of observed data based on data_type
  obs_id_name <- glue::glue("observed_{data_type}_data_id")

  # Set up distribution based on `family` argument`
  if (family[["family"]] == "lognormal") {
    # create new Rcpp module
    new_module <- methods::new(DlnormDistribution)

    # populate logged standard deviation parameter with log of input
    # Using resize() and then assigning value to each element of log_sd directly
    # is correct, as creating a new ParameterVector for log_sd here would
    # trigger an error in integration tests with wrappers.
    new_module$log_sd$resize(length(sd[["value"]]))

    purrr::walk(
      seq_along(sd[["value"]]),
      \(x) new_module[["log_sd"]][x][["value"]] <- log(sd[["value"]][x])
    )

    purrr::walk(
      seq_along(sd[["estimation_type"]]),
      \(x) new_module[["log_sd"]][x][["estimation_type"]]$set(sd[["estimation_type"]][x])
    )
  }

  if (family[["family"]] == "gaussian") {
    # create new Rcpp module
    new_module <- methods::new(DnormDistribution)

    # populate logged standard deviation parameter with log of input
    purrr::walk(
      seq_along(sd[["value"]]),
      \(x) new_module[["log_sd"]][x][["value"]] <- log(sd[["value"]][x])
    )

    purrr::walk(
      seq_along(sd[["estimation_type"]]),
      \(x) new_module[["log_sd"]][x][["estimation_type"]]$set(sd[["estimation_type"]][x])
    )
  }

  if (family[["family"]] == "multinomial") {
    # create new Rcpp module
    new_module <- methods::new(DmultinomDistribution)
  }

  # setup link to observed data
  if (data_type == "landings") {
    new_module$set_observed_data(module$GetObservedLandingsDataID())
  }
  if (data_type == "index") {
    new_module$set_observed_data(module$GetObservedIndexDataID())
  }
  if (data_type == "agecomp") {
    new_module$set_observed_data(module$GetObservedAgeCompDataID())
  }
  if (data_type == "lengthcomp") {
    new_module$set_observed_data(module$GetObservedLengthCompDataID())
  }

  # set name of expected values
  expected <- get_expected_name(family, data_type)
  # setup link to expected values
  new_module$set_distribution_links("data", module$field(expected)$get_id())

  return(new_module)
}

#' @rdname initialize_data_distribution
#' @keywords distribution
#' @export
initialize_process_distribution <- function(
  module,
  par,
  family = NULL,
  sd = tibble::tibble(
    value = 1,
    estimation_type = "constant"
  ),
  is_random_effect = FALSE
) {
  # validity check on user input
  args <- list(family = family, sd = sd)
  check_distribution_validity(args)

  expected <- switch(paste0(par, "_", class(module)),
    "log_devs_Rcpp_BevertonHoltRecruitment" = NULL,
    "log_r_Rcpp_BevertonHoltRecruitment" = "log_expected_recruitment"
  )

  # Set up distribution based on `family` argument`
  if (family[["family"]] == "lognormal") {
    # create new Rcpp module
    new_module <- methods::new(DlnormDistribution)

    # populate logged standard deviation parameter with log of input
    new_module$log_sd$resize(length(sd[["value"]]))
    purrr::walk(
      seq_along(sd[["value"]]),
      \(x) new_module[["log_sd"]][x][["value"]] <- log(sd[["value"]][x])
    )

    # setup whether or not sd parameter is estimated
    if (length(sd[["value"]]) > 1 && length(sd[["estimation_type"]]) == 1) {
      if (sd[["estimation_type"]] == "constant") {
        new_module$log_sd$set_all_estimable(FALSE)
      } else {
        new_module$log_sd$set_all_estimable(TRUE)
      }
    } else {
      for (i in seq_along(sd[["estimation_type"]])) {
        new_module$log_sd[i]$estimation_type$set(sd[["estimation_type"]][i])
      }
    }
  }

  if (family[["family"]] == "gaussian") {
    # create new Rcpp module
    new_module <- methods::new(DnormDistribution)

    # populate logged standard deviation parameter with log of input
    new_module$log_sd$resize(length(sd[["value"]]))
    for (i in seq_along(sd[["value"]])) {
      new_module$log_sd[i]$value <- log(sd[["value"]][i])
    }

    # setup whether or not sd parameter is estimated
    if (length(sd[["value"]]) > 1 && length(sd[["estimation_type"]]) == 1) {
      if (sd[["estimation_type"]] == "constant") {
        new_module$log_sd$set_all_estimable(FALSE)
      } else {
        new_module$log_sd$set_all_estimable(TRUE)
      }
    } else {
      for (i in seq_along(sd[["estimation_type"]])) {
        new_module$log_sd[i]$estimation_type$set(sd[["estimation_type"]][i])
      }
    }
  }


  n_dim <- length(module$field(par))

  # create new Rcpp modules
  new_module$observed_values$resize(n_dim)
  new_module$expected_values$resize(n_dim)

  # initialize values with 0
  # these are overwritten in the code later by user input
  for (i in 1:n_dim) {
    new_module$observed_values[i]$value <- 0
    new_module$expected_values[i]$value <- 0
  }

  # setup links to parameter
  if (is.null(expected)) {
    new_module$set_distribution_links(
      "random_effects",
      module$field(par)$get_id()
    )
  } else {
    new_module$set_distribution_links(
      "random_effects",
      c(
        module$field(par)$get_id(),
        module$field(expected)$get_id()
      )
    )
  }

  return(new_module)
}

#' @rdname initialize_data_distribution
#' @keywords distribution
#' @export
initialize_process_structure <- function(module, par) {
  new_process_module <- switch(paste0(par, "_", class(module)),
    "log_devs_Rcpp_BevertonHoltRecruitment" = new(LogDevsRecruitmentProcess),
    "log_r_Rcpp_BevertonHoltRecruitment" = new(LogRRecruitmentProcess)
  )

  module$SetRecruitmentProcessID(new_process_module$get_id())

  return(new_process_module)
}

#' Distributions not available in the stats package
#'
#' Family objects provide a convenient way to specify the details of the models
#' used by functions such as [stats::glm()]. These functions within this
#' package are not available within the stats package but are designed in a
#' similar manner.
#'
#' @param link A string specifying the model link function. For example,
#'   `"identity"` or `"log"` are appropriate names for the [stats::gaussian()]
#'   distribution. `"log"` and `"logit"` are the defaults for the lognormal and
#'   the multinomial, respectively.
#' @return
#' An object of class `family` (which has a concise print method). This
#' particular family has a truncated length compared to other distributions in
#' [stats::family()].
#' \item{family}{character: the family name.}
#' \item{link}{character: the link name.}
#'
#' @seealso
#' * [stats::family()]
#' * [stats::gaussian()]
#' * [stats::glm()]
#' * [stats::power()]
#' * [stats::make.link()]
#' @keywords distribution
#' @export
#' @examples
#' a_family <- multinomial()
#' a_family[["family"]]
#' a_family[["link"]]
lognormal <- function(link = "log") {
  family_class <- c(
    list(family = "lognormal", link = link),
    stats::make.link(link)
  )
  class(family_class) <- "family"
  return(family_class)
}

#' @rdname lognormal
#' @keywords distribution
#' @export
multinomial <- function(link = "logit") {
  family_class <- c(
    list(family = "multinomial", link = link),
    stats::make.link(link)
  )
  class(family_class) <- "family"
  return(family_class)
}

# This file contains many functions to reshape output from get_output()
# To remove the NOTE `no visible binding for global variable`
utils::globalVariables(c(
  "data", "data_id", "data_ids", "data_type",
  "delete_me",
  "density_component",
  "derived_quantities", "dimensionality",
  "fleet",
  "join_by", "json",
  "input_type",
  "label", "label_splits", "likelihood", "log_sd_values",
  "module_name", "module_id", "module_type",
  "observed_data_id", "observed_values",
  "parameter_min", "parameter_max",
  "parameters",
  "population"
))

#' Reshape JSON estimates
#'
#' @description
#' This function processes the finalized FIMS JSON output and reshapes the
#' parameter estimates into a structured tibble for easier analysis and
#' manipulation.
#'
#' @param model_output A JSON object containing the finalized FIMS output as
#'   returned from `get_output()`, which is an internal function to each model
#'   family.
#' @return A tibble containing the reshaped parameter estimates.
reshape_json_estimates <- function(model_output) {
  json_list <- jsonlite::fromJSON(model_output, simplifyVector = FALSE)
  read_list <- purrr::map(
    json_list[!names(json_list) %in% c(
      "name", "type", "estimation_framework", "id", "objective_function_value",
      "max_gradient_component", "gradient",
      "population_ids", "fleet_ids", "log"
    )],
    \(x) tidyr::unnest_wider(tibble::tibble(json = x), json)
  )

  # Process the module parameters
  module_information <- purrr::map_df(
    read_list[
      !names(read_list) %in%
        c(
          "name", "type", "estimation_framework", "id",
          "objective_function_value", "populations", "fleets", "data",
          "density_components", "population_ids", "fleet_ids"
        )
    ],
    .f = \(y) dplyr::mutate(
      y,
      parameters = purrr::map(
        parameters,
        \(x) purrr::map_df(x, dimension_folded_to_tibble)
      )
    )
  ) |>
    tidyr::unnest(parameters)

  # Process the fleet-level information
  fleet_density_data <- read_list[["fleets"]] |>
    dplyr::select(module_id, data_ids) |>
    dplyr::mutate(
      data_ids = purrr::map(
        data_ids,
        \(y) tibble::enframe(unlist(y), name = "data_type", value = "data_id")
      )
    ) |>
    tidyr::unnest(data_ids) |>
    dplyr::filter(data_id != -999) |>
    dplyr::mutate(
      name = paste(data_type, "expected", sep = "_")
    ) |>
    dplyr::left_join(
      y = read_list[["density_components"]] |>
        dplyr::filter(
          observed_data_id != -999
        ) |>
        dplyr::rename(distribution = "module_type") |>
        dplyr::select(-dplyr::starts_with("module")),
      by = c("data_id" = "observed_data_id")
    ) |>
    dplyr::mutate(
      density_component = purrr::map(density_component, density_to_tibble)
    ) |>
    tidyr::unnest(density_component) |>
    dplyr::select(-dplyr::starts_with("data_")) |>
    dplyr::group_by(module_id, name) |>
    dplyr::mutate(join_by = dplyr::row_number()) |>
    dplyr::ungroup()

  fleet_information <- read_list[["fleets"]] |>
    tidyr::pivot_longer(
      cols = c(parameters, derived_quantities),
      names_to = "delete_me",
      values_to = "parameters"
    ) |>
    dplyr::select(-delete_me, -data_ids) |>
    # Remove column ids that are not currently needed
    dplyr::select(-dplyr::matches("^n.+s$")) |>
    dplyr::mutate(
      parameters = purrr::map(
        parameters,
        \(x) purrr::map_df(x, dimension_folded_to_tibble)
      )
    ) |>
    tidyr::unnest(parameters) |>
    dplyr::group_by(module_id, name) |>
    dplyr::mutate(join_by = dplyr::row_number()) |>
    dplyr::ungroup() |>
    dplyr::left_join(
      fleet_density_data,
      by = c("module_id", "name", "join_by"),
      suffix = c("", "_density")
    ) |>
    dplyr::select(-join_by)

  # Process the data components
  # TODO: Data component needs actual uncertainty instead of 0
  data_information <- read_list[["data"]] |>
    dplyr::mutate(
      dimensionality = purrr::map(dimensionality, \(x) dimensions_to_tibble(x))
    ) |>
    tidyr::unnest(c(dimensionality, value, uncertainty)) |>
    dplyr::mutate(value = unlist(value), uncertainty = unlist(uncertainty))

  # Process the density components
  # This is done above for fleet information but we will need to do it for
  # parameter-level information once we have a link to the parameter id
  density_information <- read_list[["density_components"]] |>
    dplyr::mutate(
      density_component = purrr::map(density_component, density_to_tibble)
    ) |>
    tidyr::unnest(density_component)

  # Process the population data
  population_information <- read_list[["populations"]] |>
    tidyr::pivot_longer(
      cols = c(parameters, derived_quantities),
      names_to = "delete_me",
      values_to = "parameters"
    ) |>
    # TODO: Think about these ids when we have more than one population
    dplyr::select(-delete_me, -dplyr::ends_with("_id"), -population) |>
    dplyr::mutate(
      parameters = purrr::map(
        parameters,
        \(x) purrr::map_df(x, dimension_folded_to_tibble)
      )
    ) |>
    tidyr::unnest(parameters)

  # TODO: Change some column names
  # Bring everything together
  out <- dplyr::bind_rows(
    # density_information,
    fleet_information,
    module_information,
    population_information
  ) |>
    dplyr::select(
      module_name, module_id, module_type,
      "label" = name,
      type, type_id, "parameter_id" = id,
      fleet, dplyr::ends_with("_i"),
      "input" = value,
      estimated = "estimated_value",
      "expected" = expected_values,
      "observed" = observed_values,
      estimation_type,
      distribution,
      input_type, lpdf = "lpdf_value", likelihood,
      "log_sd" = log_sd_values,
      dplyr::everything()
    )
}

#' Reshape TMB estimates
#'
#' @description
#' This function processes the TMB std and reshapes them into a structured
#' tibble for easier analysis and manipulation.
#'
#' @param obj An object returned from [TMB::MakeADFun()].
#' @param sdreport An object of the `sdreport` class as returned from
#'   [TMB::sdreport()].
#' @param opt An object returned from an optimizer, typically from
#'   [stats::nlminb()], used to fit a TMB model. If the model is not optimized,
#'   opt is an empty list and is not used in the function.
#' @param parameter_names A character vector of parameter names. This is used to
#'   identify the parameters in the `std` object.
#' @return A tibble containing the reshaped estimates (i.e., parameters and
#' derived quantities).
reshape_tmb_estimates <- function(obj,
                                  sdreport = NULL,
                                  opt = NULL,
                                  parameter_names) {
  # Outline for the estimates table
  estimates_outline <- tibble::tibble(
    # The FIMS Rcpp module
    module_name = character(),
    # The unique ID of the module
    module_id = integer(),
    # The name of the parameter or derived quantity
    label = character(),
    # The unique ID of the parameter
    parameter_id = integer(),
    # The initial value use to start the optimization procedure
    initial = numeric(),
    # The estimated parameter value, which would be the MLE estimate or the value
    # used for a given MCMC iteration
    estimate = numeric(),
    # Estimated uncertainty, reported as a standard deviation
    uncertainty = numeric(),
    # The pointwise log-likelihood used for the test or holdout data
    log_like_cv = numeric(),
    # The gradient component for that parameter, NA for derived quantities
    gradient = numeric()
  )

  if (length(sdreport) > 0) {
    std <- summary(sdreport)
    # Number of rows for derived quantities: based on the difference
    # between the total number of rows in std and the length of parameter_names.
    derived_quantity_nrow <- nrow(std) - length(parameter_names)
    # Create a tibble with the data from the std, and then apply transformations.
    estimates <- estimates_outline |>
      tibble::add_row(
        label = dimnames(std)[[1]],
        estimate = std[, "Estimate"],
        uncertainty = std[, "Std. Error"],
        # Use obj[["env"]][["parameters"]][["p"]] as this will return both initial
        # fixed and random effects while obj[["par"]] only returns initial fixed
        # effects
        initial = c(
          obj[["env"]][["parameters"]][["p"]],
          rep(NA_real_, derived_quantity_nrow)
        ),
        gradient = c(
          obj[["gr"]](opt[["par"]]),
          rep(NA_real_, derived_quantity_nrow)
        )
      )
  } else {
    estimates <- estimates_outline |>
      tibble::add_row(
        label = names(obj[["par"]]),
        initial = obj[["env"]][["parameters"]][["p"]],
        estimate = obj[["env"]][["parameters"]][["p"]]
      )
  }

  estimates <- estimates |>
    # Split labels and extract module, id, label, and parameter id
    dplyr::mutate(label_splits = strsplit(label, split = "\\.")) |>
    dplyr::rowwise() |>
    # TODO: the code could be simplified using tidyr::separate_wider_*().
    # However, doing so would require avoiding pre-specification of these columns
    # in the estimates_outline tibble. Consider updating the code if we decide
    # not to create the `estimates_outline` tibble in advance.
    dplyr::mutate(
      module_name = ifelse(length(label_splits) > 1, label_splits[[1]], NA_character_),
      module_id = ifelse(length(label_splits) > 1, as.integer(label_splits[[2]]), NA_integer_),
      label = ifelse(length(label_splits) > 1, label_splits[[3]], label),
      parameter_id = ifelse(length(label_splits) > 1, as.integer(label_splits[[4]]), NA_integer_)
    ) |>
    dplyr::select(-label_splits) |>
    dplyr::ungroup()
}

#' Converts a dimension-folder section into a tibble
#'
#' This is an internal helper function that processes a complex list
#' structure read in from a json file containing dimensionality information, a
#' name, and either explicit values with a type or estimated values with
#' uncertainty.
#'
#' @param section A section of the json file represented as a list.
#' @return
#' A tibble containing the json output in a formatted structure listing the
#' dimensionality as columns rather than just row and column lengths.
#' @noRd
#'
#' @examples
#' # A simple example for a value with uncertainty:
#' section_derived <- list(
#'   name = "derived_quantity_name",
#'   dimensionality = list(
#'     unit = "m", symbol = "L", scale = 1.0, type = "length"
#'   ),
#'   value = 10.5,
#'   uncertainty = 0.5
#' )
#' dimension_folded_to_tibble(section_derived)
dimension_folded_to_tibble <- function(section) {
  if (length(section) == 0) {
    return(NA)
  }
  while (length(section) == 1) {
    section <- unlist(section, recursive = FALSE)
  }
  temp <- dimensions_to_tibble(section[["dimensionality"]]) |>
    dplyr::mutate(name = section[["name"]])
  if ("type" %in% names(section)) {
    temp |>
      dplyr::mutate(
        # TODO: Need to rename
        type_id = section[["id"]],
        type = section[["type"]]
      ) |>
      dplyr::bind_cols(
        tibble::tibble(data = section[["values"]]) |>
          tidyr::unnest_wider(data)
      )
  } else {
    temp |>
      dplyr::bind_cols(
        estimated_value = unlist(section[["value"]]),
        estimation_type = "derived_quantity"
      )
  }
}

#' Covert the dimension information from a FIMS json output into a tibble
#'
#' Dimensions in the json output are stored as a list of length two, with the
#' header information containing the name of the dimension and the dimensions
#' containing integers specifying the length for each dimension. The result
#' helps interpret how the FIMS output is structured given it is dimension
#' folded into a single vector in the json output.
#'
#' @details
#' The dimension index is returned not the actual year of the model. For
#' example, if the model starts in year 1900, then year_i of 1, which is what
#' is returned from this function will need to map to 1900 and that will need
#' to be done externally.
#' This function will accommodate dimensions of year-1 and year+1 where the
#' indexing of the former will start at 2 instead of 1.
#' @param data A list containing the header and dimensions information from a
#'   FIMS json output object.
#' @return
#' A tibble containing ordered rows for each combination of the dimensions.
#' @noRd
#' @examples
#' dummy_dimensions <- list(
#'   header = list("n_years", "n_ages"),
#'   dimensions = list(30L, 12L)
#' )
#' dimensions_to_tibble(dummy_dimensions)
#' # Example with n_years+1
#' dummy_dimensions <- list(
#'   header = list("n_years+1", "n_ages"),
#'   dimensions = list(31L, 12L)
#' )
#' dimensions_to_tibble(dummy_dimensions)
dimensions_to_tibble <- function(data) {
  #' Replace headers like "n_years" with "year_i".
  #' Example: "n_ages+1" with "age_i"
  #' This matches names starting with 'n' (with or without an underscore)
  #' and shortens them to a simple indexed form.
  better_names <- unlist(data[["header"]]) |>
    gsub(pattern = "^n_?(.+?)s([-\\+]\\d+)?$", replacement = "\\1_i")
  names(data[["dimensions"]]) <- better_names
  if (length(better_names) == 0) {
    # When the header is NULL
    return(tibble::add_row(tibble::tibble()))
  }
  if ("na" %in% better_names && length(better_names) == 1) {
    # When the dimensions are na because there is no associated indexing
    return(tibble::add_row(tibble::tibble()))
  }
  # Accommodate any -1 by creating a different start value
  test <- grepl("-\\d", data[["header"]])
  addition <- gsub(".+-(\\d)", "\\1", data[["header"]])
  addition[!test] <- 0
  start <- 1 + as.numeric(addition)
  data[["dimensions"]][test] <- as.numeric(data[["dimensions"]][test]) +
    as.numeric(addition)
  # Create the returned tibble by first sequencing from 1:n for each dimension
  purrr::map2(start, data[["dimensions"]], seq) |>
    purrr::set_names(names(data[["dimensions"]])) |>
    expand.grid() |>
    tibble::as_tibble() |>
    dplyr::arrange(!!!rlang::syms(better_names))
}

#' Convert the density component information into a tibble
#'
#' @description
#' The log probability density function (lpdf) information is information in
#' the json that pertains to a distribution, which is often associated with a
#' data stream. For example, the lognormal distribution can be associated with
#' landings for a given fleet because those landings might be uncertain.
#'
#' @details
#' The raw information, i.e., `data` is a list of unknown dimensions, where the
#' first element of the list, i.e., `lpdf_value`, is a single numeric value and
#' the remaining list elements are lists themselves. This function converts the
#' list to a tibble and then extracts only columns that have some derivative of
#' "value" in their name, e.g., `lpdf_value`, `expected_values`, etc., using
#' regular expression matching. Thus, when `data` does not have an entry for
#' `log_sd_values` the function does not fail but will return a smaller tibble
#' than normal.
#'
#' It is imperative that each list element of `data` be of length one or the
#' exact same length as the other elements. There is an internal check in the
#' function for this consistency.
#'
#' The code that writes this json information is stored in `inst/include/interface/rcpp/rcpp_objects/rcpp_distribution.hpp`.
#' @param data A list of `density_components` from the json output that is a
#'   list of lists. The first element of the list will be `lpdf_value`, a
#'   single entry that stores the log probability density function value. The
#'   remaining list elements have "value" in their name and are formatted as
#'   lists themselves.
#' @return
#' A tibble is returned with the `lpdf_value` first and then other columns with
#' value in their name following. The columns will be in the same order they
#' are reported in the json output.
#' @noRd
#'
#' @examples
#' dummy_density <- list(
#'   name = "lpdf_vec",
#'   lpdf_value = -102.079,
#'   values = list(
#'     -1.39915, -2.44735, -2.93024, -3.21848, -2.95698, -3.51745
#'   ),
#'   expected_values = list(
#'     5.0854, 6.13354, 6.61636, 6.90467, 6.64311, 7.20302
#'   ),
#'   observed_values = list(
#'     161.646, 461.089, 747.29, 996.971, 767.548, 1343.86
#'   )
#' )
#' density_to_tibble(dummy_density)
#' @noRd
density_to_tibble <- function(data) {
  # Check that each list element is of length-one or the same length otherwise
  # the resulting tibble will not be the correct dimensions
  element_lengths <- purrr::map_int(data, length)
  check <- if (all(element_lengths == 1)) {
    TRUE
  } else {
    length(unique(element_lengths[element_lengths != 1])) == 1
  }
  if (!check) {
    cli::cli_abort(
      "Not all elements in the density component information are equal or of
      length 1, their lengths are as follows: {element_lengths}.
      The lpdf_value of this element is {data[['lpdf_value']][1]}."
    )
  }

  # Return the tibble
  data |>
    tibble::as_tibble() |>
    tidyr::unnest(dplyr::contains("value")) |>
    dplyr::rename(likelihood = value)
}

# To remove the WARNING
# no visible binding for global variable
utils::globalVariables(c(
  "everything", "fleet_name"
))

#' Create a default FIMS configuration tibble
#'
#' @description
#' This function generates a default configuration tibble for a Fisheries
#' Integrated Modeling System (FIMS) model based on the data input. It
#' automatically creates configuration entries for data modules (e.g., landings,
#' index, compositions) and, depending on the model family, standard population
#' dynamics modules (recruitment, growth, maturity) and selectivity modules for
#' fleets.
#'
#' @details
#' The function inspects the data to find unique combinations of fleet
#' names and data types. It then maps these to the appropriate FIMS module names
#' and joins them with a predefined template of default settings. When the
#' `model_family` is "catch_at_age", it also adds default configurations for:
#' \itemize{
#'   \item **Selectivity:** A logistic selectivity module for each unique fleet.
#'   \item **Recruitment:** A Beverton--Holt recruitment module.
#'   \item **Growth:** An empirical weight-at-age (EWAA) growth module.
#'   \item **Maturity:** A logistic maturity module.
#' }
#' The final output is a nested tibble, which serves as a starting point for
#' building a complete FIMS model configuration.
#'
#' @param data An S4 object of class `FIMSFrame`. FIMS input data.
#' @param model_family A string specifying the model family.
#'   Defaults to `"catch_at_age"`.
#'
#' @return A `tibble` with default model configurations. The tibble has a nested
#'   structure with the following top-level columns.
#' \describe{
#'   \item{\code{model_family}:}{The specified model family (e.g.,
#'     "catch_at_age").}
#'   \item{\code{module_name}:}{The name of the FIMS module (e.g.,
#'     "Data", "Selectivity", "Recruitment", "Growth", "Maturity").}
#'   \item{\code{fleet_name}:}{The name of the fleet the module applies to. This
#'     will be `NA` for non-fleet-specific modules like "Recruitment".}
#'   \item{\code{data}:}{A list-column containing a `tibble` with detailed
#'     configurations. Unnesting this column reveals:
#'     \describe{
#'       \item{\code{module_type}:}{The specific type of the module (e.g.,
#'         "Logistic" for a "Selectivity" module).}
#'       \item{\code{distribution_link}:}{The component the distribution module
#'         links to.}
#'       \item{\code{distribution_type}:}{The type of distribution (e.g., "Data",
#'         "process").}
#'       \item{\code{distribution}:}{The name of distribution (e.g.,
#'         "Dlnorm", `Dmultinom`).}
#'     }
#'   }
#' }
#'
#' @export
#'
#' @examples
#' # Load the example dataset and create a FIMS data frame
#' data("data_big")
#' fims_frame <- FIMSFrame(data_big)
#'
#' # Create the default model configuration tibble
#' default_configurations <- create_default_configurations(data = fims_frame)
#'
#' # Unnest the data column to see detailed configurations
#' default_configurations_unnest <- default_configurations |>
#'   tidyr::unnest(cols = data) |>
#'   print()
#'
#' # Model fleet1 with double logistic selectivity
#' configurations_double_logistic <- default_configurations_unnest |>
#'   dplyr::rows_update(
#'     tibble::tibble(
#'       module_name = "Selectivity",
#'       fleet_name = "fleet1",
#'       module_type = "DoubleLogistic"
#'     ),
#'     by = c("module_name", "fleet_name")
#'   ) |>
#'   print()
create_default_configurations <- function(data, model_family = c("catch_at_age")) {
  # Check if the input object is a FIMSFrame, aborting if not.
  if (!inherits(data, "FIMSFrame")) {
    cli::cli_abort(
      c(
        "{.var data} must be a {.cls FIMSFrame} object.",
        "i" = "Please convert your data before using this function."
      )
    )
  }

  # Ensures the user input matches the options provided,
  #   if not, then match.arg() throws an error
  model_family <- match.arg(model_family)

  # Extract unique combinations of fleet names and data types from the data.
  # This forms the basis for determining which modules are needed for each fleet.
  unique_fleet_types <- data |>
    get_data() |>
    dplyr::distinct(name, type) |>
    # Convert type from snake_case to PascalCase
    dplyr::mutate(module_type = snake_to_pascal(type)) |>
    # Set module_type to NA for weight-at-age and age-to-length-conversion
    dplyr::mutate(module_type = dplyr::case_when(
      type == "weight_at_age" ~ NA_character_,
      type == "age_to_length_conversion" ~ NA_character_,
      TRUE ~ module_type
    )) |>
    # Remove any combinations where the type did not match a known module.
    dplyr::filter(!is.na(module_type)) |>
    dplyr::rename(fleet_name = name) |>
    dplyr::select(-type)

  # Define a template for data modules (comps, landings, index).
  # This specifies the default distribution for each type of data.
  data_config_template <- dplyr::tribble(
    ~module_name, ~module_type, ~distribution_link, ~distribution_type, ~distribution,
    "Data", "Landings", "Landings", "Data", "Dlnorm",
    "Data", "Index", "Index", "Data", "Dlnorm",
    "Data", "AgeComp", "AgeComp", "Data", "Dmultinom",
    "Data", "LengthComp", "LengthComp", "Data", "Dmultinom"
  )

  # Create data module configurations by joining the unique fleet types
  # with the corresponding template entries.
  fleet_data_config <- unique_fleet_types |>
    dplyr::left_join(data_config_template, by = "module_type")

  # Initialize placeholders for conditional configurations.
  selectivity_config <- tibble::tibble()
  other_config <- tibble::tibble()

  # If model_family is "catch_at_age", create selectivity configurations for
  # fleets and other configurations for population dynamics.
  if (model_family == "catch_at_age") {
    # Create these rows by getting distinct fleet names and joining them
    # with the selectivity template.
    selectivity_config <- unique_fleet_types |>
      dplyr::distinct(fleet_name) |>
      dplyr::mutate(
        module_name = "Selectivity",
        module_type = "Logistic"
      )

    # Define a template for standard, non-fleet-specific modules.
    other_config <- dplyr::tribble(
      ~module_name, ~module_type, ~distribution_link, ~distribution_type, ~distribution,
      "Recruitment", "BevertonHolt", "log_devs", "process", "Dnorm",
      "Growth", "EWAA", NA_character_, NA_character_, NA_character_,
      "Maturity", "Logistic", NA_character_, NA_character_, NA_character_
    )
  }

  # Combine all configuration pieces into a single tibble.
  # The `dplyr::bind_rows` function intelligently handles differing columns
  # by filling missing values with NA.
  final_config <- dplyr::bind_rows(
    fleet_data_config,
    selectivity_config,
    other_config
  ) |>
    # Add model_family column
    dplyr::mutate(model_family = model_family) |>
    # Arrange for readability.
    dplyr::arrange(fleet_name, module_name) |>
    # Reorder columns
    dplyr::select(
      model_family, module_name, module_type, fleet_name, everything()
    ) |>
    # Nest the configuration details into a list-column called 'data'.
    # This creates the final, structured output format expected by FIMS.
    tidyr::nest(.by = c(model_family, module_name, fleet_name))
}

#' Convert snake_case strings to PascalCase
#'
#' This function takes a vector of strings in snake_case format and converts
#' them to PascalCase.
#'
#' @param snake_strings A vector of strings in snake_case format.
#' @return A vector of strings in PascalCase format.
#' @examples
#' snake_to_pascal(c("age_comp", "length_comp"))
#' snake_to_pascal("index")
#' @noRd
snake_to_pascal <- function(snake_strings) {
  purrr::map_chr(snake_strings, \(x) {
    parts <- strsplit(x, "_")[[1]]
    paste(
      toupper(substring(parts, 1, 1)),
      substring(parts, 2),
      sep = "",
      collapse = ""
    )
  })
}

#' Should FIMS be verbose?
#'
#' Verbosity is set globally for FIMS using
#' `options(rlib_message_verbosity = "quiet")` to stop the printing of messages
#' from `cli::cli_inform()`. Using a global option allows for verbose to not
#' have to be an argument to every function. All `cli::cli_abort()` messages are
#' printed to the console no matter what the global option is set to.
#'
#' @return
#' A logical is returned where `TRUE` ensures messages from `cli::cli_inform()`
#' are printed to the console.
#'
#' @examples
#' # function is not exported
#' \dontrun{
#' FIMS:::is_fims_verbose()
#' }
is_fims_verbose <- function() {
  verbose_option <- getOption("rlib_message_verbosity", default = "default")
  verbose_boolean <- verbose_option %in% c("default", "verbose")
  return(verbose_boolean)
}

/**
 * @file data_object.hpp
 * @brief Sets up a data class to create a generic data object with up to five
 * dimensions. The class contains internal vector for data elements and
 * uncertainty values.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_COMMON_DATA_OBJECT_HPP
#define FIMS_COMMON_DATA_OBJECT_HPP

#include <exception>
#include <vector>

#include "model_object.hpp"
#include "fims_vector.hpp"

namespace fims_data_object {

/**
 * Container to hold user supplied data.
 */
template <typename Type>
struct DataObject : public fims_model_object::FIMSObject<Type> {
  static uint32_t id_g;                    /**< id of the Data Object >*/
  fims::Vector<Type> data;                 /**< vector of the data >*/
  fims::Vector<Type> uncertainty;          /**< vector of the data >*/
  size_t dimensions;                       /**< dimension of the Data object >*/
  size_t imax;                             /**< 1st dimension of data object >*/
  size_t jmax;                             /**< 2nd dimension of data object>*/
  size_t kmax;                             /**< 3rd dimension of data object>*/
  size_t lmax;                             /**< 4th dimension of data object>*/
  Type na_value = static_cast<Type>(-999); /**< specifying the NA value >*/

  /**
   * Constructs a one-dimensional data object.
   */
  DataObject(size_t imax) : dimensions(1), imax(imax) {
    data.resize(imax);
    uncertainty.resize(imax);
    this->id = DataObject<Type>::id_g++;
  }

  /**
   * Constructs a two-dimensional data object.
   */
  DataObject(size_t imax, size_t jmax) : dimensions(2), imax(imax), jmax(jmax) {
    data.resize(imax * jmax);
    uncertainty.resize(imax * jmax);
    this->id = DataObject<Type>::id_g++;
  }

  /**
   *  Constructs a three-dimensional data object.
   */
  DataObject(size_t imax, size_t jmax, size_t kmax)
      : dimensions(3), imax(imax), jmax(jmax), kmax(kmax) {
    data.resize(imax * jmax * kmax);
    uncertainty.resize(imax * jmax * kmax);
    this->id = DataObject<Type>::id_g++;
  }

  /**
   * Constructs a four-dimensional data object.
   */
  DataObject(size_t imax, size_t jmax, size_t kmax, size_t lmax)
      : dimensions(4), imax(imax), jmax(jmax), kmax(kmax), lmax(lmax) {
    data.resize(imax * jmax * kmax * lmax);
    uncertainty.resize(imax * jmax * kmax * lmax);
    this->id = DataObject<Type>::id_g++;
  }

  /**
   * Retrieve element from 1d data set.
   * @param i dimension of 1d data set
   * @return the value of the vector at position i
   */
  inline Type operator()(size_t i) { return data[i]; }

  /**
   * Retrieve element from 1d data set.
   * Throws an exception if index is out of bounds.
   * @param i dimension of 1d data set
   * @return the reference to the value of the vector at position i
   */
  inline Type& at(size_t i) {
    if (i >= this->data.size()) {
      throw std::overflow_error("DataObject error:i index out of bounds");
    }
    return data[i];
  }

  /**
   * Retrieve element from 2d data set.
   * @param i 1st dimension of 2d data set
   * @param j 2nd dimension of 2d data set
   * @return the value of the matrix at position i, j
   */
  inline const Type operator()(size_t i, size_t j) {
    return data[i * jmax + j];
  }

  /**
   * Retrieve element from 2d data set.
   * Throws an exception if index is out of bounds.
   * @param i 1st dimension of 2d data set
   * @param j 2nd dimension of 2d data set
   * @return the reference to the value of the matrix at position i, j
   */
  inline Type& at(size_t i, size_t j) {
    if ((i * jmax + j) >= this->data.size()) {
      throw std::overflow_error("DataObject error: index out of bounds");
    }
    return data[i * jmax + j];
  }

  /**
   * Retrieve element from 3d data set.
   * @param i 1st dimension of 3d data set
   * @param j 2nd dimension of 3d data set
   * @param k 3rd dimension of 3d data set
   * @return the value of the array at position i, j, k
   */
  inline const Type operator()(size_t i, size_t j, size_t k) {
    return data[i * jmax * kmax + j * kmax + k];
  }

  /**
   * Retrieve element from 3d data set.
   * Throws an exception if index is out of bounds.
   * @param i 1st dimension of 3d data set
   * @param j 2nd dimension of 3d data set
   * @param k 3rd dimension of 3d data set
   * @return the reference to the value of the array at position i, j, k
   */
  inline Type& at(size_t i, size_t j, size_t k) {
    if ((i * jmax * kmax + j * kmax + k) >= this->data.size()) {
      throw std::overflow_error("DataObject error: index out of bounds");
    }
    return data[i * jmax * kmax + j * kmax + k];
  }

  /**
   * Retrieve element from 4d data set.
   * @param i 1st dimension of 4d data set
   * @param j 2nd dimension of 4d data set
   * @param k 3rd dimension of 4d data set
   * @param l 4th dimension of 4d data set
   * @return the value of the array at position i, j, k, l
   */
  inline const Type operator()(size_t i, size_t j, size_t k, size_t l) {
    return data[i * jmax * kmax * lmax + j * kmax * lmax + k * lmax + l];
  }

  /**
   * Retrieve element from 3d data set.
   * Throws an exception if index is out of bounds.
   * @param i 1st dimension of 4d data set
   * @param j 2nd dimension of 4d data set
   * @param k 3rd dimension of 4d data set
   * @param l 4th dimension of 4d data set
   * @return the reference to the value of the array at position i, j, k, l
   */
  inline Type& at(size_t i, size_t j, size_t k, size_t l) {
    if ((i * jmax * kmax * lmax + j * kmax * lmax + k * lmax + l) >=
        this->data.size()) {
      throw std::overflow_error("DataObject error: index out of bounds");
    }
    return data[i * jmax * kmax * lmax + j * kmax * lmax + k * lmax + l];
  }

  /**
   * @brief Get the dimensions object
   *
   * @return size_t
   */
  size_t get_dimensions() const { return dimensions; }

  /**
   * @brief Get the imax object
   *
   * @return size_t
   */
  size_t get_imax() const { return imax; }

  /**
   * @brief Get the jmax object
   *
   * @return size_t
   */
  size_t get_jmax() const { return jmax; }

  /**
   * @brief Get the kmax object
   *
   * @return size_t
   */
  size_t get_kmax() const { return kmax; }

  /**
   * @brief Get the lmax object
   *
   * @return size_t
   */
  size_t get_lmax() const { return lmax; }
};

template <typename Type>
uint32_t DataObject<Type>::id_g = 0;

}  // namespace fims_data_object

#endif

/**
 * @file def.hpp
 * @brief Creates pre-processing macros such as what type of machine you are on
 * and creates the log information.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef DEF_HPP
#define DEF_HPP
#include <fstream>
#include <map>
#include <memory>
#include <vector>
#include <string>
#include <unordered_map>

#include <cstdlib>
#include <chrono>
#include <sstream>
#include <iostream>
#include <filesystem>
#include <stdlib.h>
#include <fstream>
#include <signal.h>
#include <csignal>
#include <cstring>

#include <stdexcept>

#if defined(linux) || defined(__linux) || defined(__linux__)
#define FIMS_LINUX
#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || \
    defined(__DragonFly__)
#define FIMS_BSD
#elif defined(sun) || defined(__sun)
#define FIMS_SOLARIS
#elif defined(__sgi)
#define FIMS_IRIX
#elif defined(__hpux)
#define FIMS_HPUX
#elif defined(__CYGWIN__)
#define FIMS_CYGWIN
#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
#define FIMS_WIN32
#elif defined(_WIN64) || defined(__WIN64__) || defined(WIN64)
#define FIMS_WIN64
#elif defined(__BEOS__)
#define FIMS_BEOS
#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
#define FIMS_MACOS
#elif defined(__IBMCPP__) || defined(_AIX)
#define FIMS_AIX
#elif defined(__amigaos__)
#define FIMS_AMIGAOS
#elif defined(__QNXNTO__)
#define FIMS_QNXNTO
#endif

#if defined(FIMS_WIN32) || defined(FIMS_WIN64)
#define FIMS_WINDOWS
#endif

#ifdef FIMS_WINDOWS
#include <Windows.h>
#include <Lmcons.h>  // for UNLEN
#elif defined(FIMS_LINUX) || defined(FIMS_MACOS) || defined(FIMS_BSD)
#include <unistd.h>
#include <pwd.h>
#endif

#if !defined(__PRETTY_FUNCTION__) && !defined(__GNUC__)
#ifdef FIMS_WINDOWS
#define __PRETTY_FUNCTION__ __FUNCTION__
#endif
#endif

// The following rows initialize default log files for outputting model progress
// comments used to assist in diagnosing model issues and tracking progress.
// These files will only be created if a logs folder is added to the root model
// directory.

#ifdef TMB_MODEL
// simplify access to singletons
#define TMB_FIMS_REAL_TYPE double
#define TMBAD_FIMS_TYPE TMBad::ad_aug
#endif

namespace fims {

/**
 * Log entry.
 */
struct LogEntry {
  /** The date/time that the log entry was created, e.g., "Oct 28 09:18:51
   * 2024". You can track how long it took to work through each portion of the
   * model by analyzing the progression of the timestamp through the log file.*/
  std::string timestamp;
  /** The description of the log entry, e.g., "Adding Selectivity object to TMB"
   * or "Mismatch dimension error", where the descriptions are predefined in the
   * C++ code. Please make a GitHub issue or contact a developer if you have
   * ideas for a more informative description.*/
  std::string message;
  /** The logging level, which is a result of which macro was used to generate
   * the message, e.g., FIMS_INFO_LOG(), FIMS_WARNING_LOG(), or FIMS_ERROR_LOG()
   * results in "info", "warning", or "error", respectively, in the log file.*/
  std::string level;
  /** The message id, directly corresponds to the order in which the entries
   * were created, e.g., "1", which is helpful for knowing the order of
   * operations within the code base and comparing log files across model
   * runs.*/
  size_t rank;
  /** The user name registered to the computer where the log file was created,
   * e.g., "John.Doe".*/
  std::string user;
  /** The working directory for the R environment that created the log file,
   * e.g., "C:/github/NOAA-FIMS/FIMS/vignettes" if you are on a Windows machine
   * or "/home/oppy/FIMS-Testing/dev/dev_logging/FIMS/vignettes" if you are on a
   * linux machine.*/
  std::string wd;
  /** The full file path of the file that triggered the log entry, e.g.,
   * "C:/github/NOAA-FIMS/FIMS/inst/include/interface/rcpp/rcpp_objects/rcpp_selectivity.hpp".*/
  std::string file;
  /** The function or method that led to the initialization the log entry, e.g.,
   * "virtual bool LogisticSelectivityInterface::add_to_fims_tmb()". If the
   * function is templated, then the function type will be reported here in
   * square brackets after the function name, e.g., "bool
   * fims_info::Information<Type>::CreateModel() [with Type = double]".*/
  std::string routine;
  /** The line in `file` where the log entry was initiated, e.g., "219", which
   * will be a line inside of the `routine` listed above.*/
  int line;

  /**
   * Convert this object to a string.
   */
  std::string to_string() {
    std::stringstream ss;
    ss << "\"timestamp\": " << "\"" << this->timestamp << "\"" << ",\n";
    ss << "\"level\": " << "\"" << this->level << "\",\n";
    ss << "\"message\": " << "\"" << this->message << "\",\n";
    ss << "\"id\": " << "\"" << this->rank << "\",\n";
    ss << "\"user\": " << "\"" << this->user << "\",\n";
    ss << "\"wd\": " << "\"" << this->wd << "\",\n";
    ss << "\"file\": " << "\"" << this->file << "\",\n";
    ss << "\"routine\": " << "\"" << this->routine << "\",\n";
    ss << "\"line\": " << "\"" << this->line << "\"\n";
    return ss.str();
  }
};

/**
 * FIMS logging class.
 */
class FIMSLog {
  std::vector<std::string> entries;
  std::vector<LogEntry> log_entries;
  size_t entry_number = 0;
  std::string path = "fims.log";
  size_t warning_count = 0;
  size_t error_count = 0;

  /**
   * Get username.
   *
   * @return username.
   */
  std::string get_user() {
#ifdef FIMS_WINDOWS
    char username[UNLEN + 1];
    DWORD username_len = UNLEN + 1;
    if (GetUserNameA(username, &username_len)) {
      return std::string(username);
    } else {
      return "[unknown user]";
    }

#elif defined(FIMS_LINUX) || defined(FIMS_MACOS) || defined(FIMS_BSD)
    const char* user_env = getenv("USER");
    if (user_env) return std::string(user_env);

    uid_t uid = getuid();
    struct passwd* pw = getpwuid(uid);
    if (pw && pw->pw_name) {
      return std::string(pw->pw_name);
    } else {
      return "[unknown user]";
    }

#else
    return "[unsupported platform]";
#endif
  }

 public:
  /**
   * @brief A boolean specifying if the log file is written when the session is
   * terminated. The default is TRUE.
   *
   */
  bool write_on_exit = true;
  /**
   * @brief A boolean specifying if the program is stopped upon the first
   * error, where the default is FALSE. This allows you go through an entire
   * program to collect all error messages.
   *
   */
  bool throw_on_error = false;
  /**
   * @brief A singleton instance of the log, i.e., where there is only one
   * log. The object is created when the .dll is loaded and it will never
   * be recreated while the .dll is loaded.
   *
   */
  static std::shared_ptr<FIMSLog> fims_log;

  /**
   * Default constructor for FIMSLog.
   */
  FIMSLog() {}

  /**
   * Destructor. If write_on_exit is set to true,
   * the log will be written to the disk in JSON format.
   */
  ~FIMSLog() {
    if (this->write_on_exit) {
      std::ofstream log(this->path);
      log << this->get_log();
      log.close();
    }
  }

  /**
   * @brief Get the Absolute Path Without Dot Dot object
   *
   * Dot dot notation is for relative paths, where this function replaces
   * all dot dots with the actual full path.
   *
   * @param relativePath A path in your file system.
   * @return std::filesystem::path
   */
  std::filesystem::path getAbsolutePathWithoutDotDot(
      const std::filesystem::path& relativePath) {
    std::filesystem::path absolutePath =
        std::filesystem::absolute(relativePath);

    std::filesystem::path result;
    for (const auto& part : absolutePath) {
      if (part == "..") {
        if (!result.empty()) {
          result = result.parent_path();
        }
      } else {
        result /= part;
      }
    }

    return result.generic_string();
  }

  /**
   * Set a path for the log file.
   *
   * @param path
   */
  void set_path(std::string path) { this->path = path; }

  /**
   * Get the path for the log file.
   *
   * @return
   */
  std::string get_path() { return this->path; }

  /**
   * Add a "info" level message to the log.
   *
   * @param str
   * @param line
   * @param file
   * @param func
   */
  void info_message(std::string str, int line, const char* file,
                    const char* func) {
    std::filesystem::path relativePath = file;
    std::filesystem::path absolutePath =
        getAbsolutePathWithoutDotDot(relativePath);
    std::filesystem::path cwd = std::filesystem::current_path();
    std::stringstream ss;
    auto now = std::chrono::system_clock::now();
    std::time_t now_time = std::chrono::system_clock::to_time_t(now);
    std::string ctime_no_newline = strtok(ctime(&now_time), "\n");

    LogEntry l;
    l.timestamp = ctime_no_newline;
    l.message = str;
    l.level = "info";
    l.rank = this->log_entries.size();
    l.user = this->get_user();
    l.wd = cwd.generic_string();
    l.file = absolutePath.string();
    l.line = line;
    l.routine = func;
    this->log_entries.push_back(l);
  }

  /**
   * Add a "error" level message to the log.
   *
   * @param str
   * @param line
   * @param file
   * @param func
   */
  void error_message(std::string str, int line, const char* file,
                     const char* func) {
    this->error_count++;
    std::filesystem::path relativePath = file;
    std::filesystem::path absolutePath =
        getAbsolutePathWithoutDotDot(relativePath);
    std::filesystem::path cwd = std::filesystem::current_path();

    std::stringstream ss;
    auto now = std::chrono::system_clock::now();
    std::time_t now_time = std::chrono::system_clock::to_time_t(now);
    std::string ctime_no_newline = strtok(ctime(&now_time), "\n");

    LogEntry l;
    l.timestamp = ctime_no_newline;
    l.message = str;
    l.level = "error";
    l.rank = this->log_entries.size();
    l.user = this->get_user();
    l.wd = cwd.generic_string();
    l.file = absolutePath.string();
    l.line = line;
    l.routine = func;
    this->log_entries.push_back(l);

    if (this->throw_on_error) {
      std::stringstream ss;
      ss << "\n\n" << l.to_string() << "\n\n";
      throw std::runtime_error(ss.str().c_str());
    }
  }

  /**
   * Add a "warning" level message to the log.
   *
   * @param str
   * @param line
   * @param file
   * @param func
   */
  void warning_message(std::string str, int line, const char* file,
                       const char* func) {
    this->warning_count++;
    std::filesystem::path relativePath = file;
    std::filesystem::path absolutePath =
        getAbsolutePathWithoutDotDot(relativePath);
    std::filesystem::path cwd = std::filesystem::current_path();

    std::stringstream ss;
    auto now = std::chrono::system_clock::now();
    std::time_t now_time = std::chrono::system_clock::to_time_t(now);
    std::string ctime_no_newline = strtok(ctime(&now_time), "\n");

    LogEntry l;
    l.timestamp = ctime_no_newline;
    l.message = str;
    l.level = "warning";
    l.rank = this->log_entries.size();
    l.user = this->get_user();
    l.wd = cwd.generic_string();
    l.file = absolutePath.string();
    l.line = line;
    l.routine = func;
    this->log_entries.push_back(l);
  }

  /**
   * Get the log as a string object.
   *
   * @return
   */
  std::string get_log() {
    std::stringstream ss;
    if (log_entries.size() == 0) {
      ss << "[\n]";
    } else {
      ss << "[\n";
      for (size_t i = 0; i < log_entries.size() - 1; i++) {
        ss << "{\n" << this->log_entries[i].to_string() << "},\n";
      }
      ss << "{\n"
         << this->log_entries[log_entries.size() - 1].to_string() << "}\n]";
    }
    return ss.str();
  }

  /**
   * Return only error entries from the log.
   *
   * @return
   */
  std::string get_errors() {
    std::stringstream ss;
    std::vector<LogEntry> errors;
    for (size_t i = 0; i < log_entries.size(); i++) {
      if (log_entries[i].level == "error") {
        errors.push_back(this->log_entries[i]);
      }
    }

    if (errors.size() == 0) {
      ss << "[\n]";
    } else {
      ss << "[\n";
      for (size_t i = 0; i < errors.size() - 1; i++) {
        ss << "{\n" << errors[i].to_string() << "},\n";
      }

      ss << "{\n" << errors[errors.size() - 1].to_string() << "}\n]";
    }
    return ss.str();
  }

  /**
   * Return only warning entries from the log.
   *
   * @return
   */
  std::string get_warnings() {
    std::stringstream ss;
    std::vector<LogEntry> warnings;
    for (size_t i = 0; i < log_entries.size(); i++) {
      if (log_entries[i].level == "warning") {
        warnings.push_back(this->log_entries[i]);
      }
    }

    if (warnings.size() == 0) {
      ss << "[\n]";
    } else {
      ss << "[\n";
      for (size_t i = 0; i < warnings.size() - 1; i++) {
        ss << "{\n" << warnings[i].to_string() << "},\n";
      }

      ss << "{\n" << warnings[warnings.size() - 1].to_string() << "}\n]";
    }
    return ss.str();
  }

  /**
   * Return only info entries from the log.
   *
   * @return
   */
  std::string get_info() {
    std::stringstream ss;
    std::vector<LogEntry> info;
    for (size_t i = 0; i < log_entries.size(); i++) {
      if (log_entries[i].level == "info") {
        info.push_back(this->log_entries[i]);
      }
    }

    if (info.size() == 0) {
      ss << "[\n]";
    } else {
      ss << "[\n";
      for (size_t i = 0; i < info.size() - 1; i++) {
        ss << "{\n" << info[i].to_string() << "},\n";
      }

      ss << "{\n" << info[info.size() - 1].to_string() << "}\n]";
    }
    return ss.str();
  }

  /**
   * Query the log by module.
   *
   * @param module
   * @return
   */
  std::string get_module(const std::string& module) {
    std::stringstream ss;
    std::vector<LogEntry> info;
    for (size_t i = 0; i < log_entries.size(); i++) {
      if (log_entries[i].file.find(module) != std::string::npos) {
        info.push_back(this->log_entries[i]);
      }
    }

    if (info.size() == 0) {
      ss << "[\n]";
    } else {
      ss << "[\n";
      for (size_t i = 0; i < info.size() - 1; i++) {
        ss << "{\n" << info[i].to_string() << "},\n";
      }

      ss << "{\n" << info[info.size() - 1].to_string() << "}\n]";
    }
    return ss.str();
  }

  /**
   * @brief Get the counts of the number of errors
   */
  size_t get_error_count() const { return error_count; }

  /**
   * @brief Get the counts of the number of warnings
   */
  size_t get_warning_count() const { return warning_count; }

  /**
   * @brief Clears all pointers/references of a FIMS model.
   *
   */
  void clear() {
    this->entries.clear();
    this->log_entries.clear();
    this->warning_count = 0;
    this->entry_number = 0;
  }
};

std::shared_ptr<FIMSLog> FIMSLog::fims_log = std::make_shared<FIMSLog>();

}  // namespace fims

#define FIMS_INFO_LOG(MESSAGE)           \
  fims::FIMSLog::fims_log->info_message( \
      MESSAGE, __LINE__, __FILE__,       \
      __PRETTY_FUNCTION__); /**< Print MESSAGE to info log */

#define FIMS_WARNING_LOG(MESSAGE)           \
  fims::FIMSLog::fims_log->warning_message( \
      MESSAGE, __LINE__, __FILE__,          \
      __PRETTY_FUNCTION__); /**< Print MESSAGE to warning log */

#define FIMS_ERROR_LOG(MESSAGE)           \
  fims::FIMSLog::fims_log->error_message( \
      MESSAGE, __LINE__, __FILE__,        \
      __PRETTY_FUNCTION__); /**< Print MESSAGE to error log */

#define FIMS_STR(s) #s /**< String of s */

namespace fims {

/**
 * Signal intercept function. Writes the log to the disk before
 * a crash occurs.
 *
 * @param sig
 */
void WriteAtExit(int sig) {
  std::string signal_error = "NA";
  switch (sig) {
    case SIGSEGV:
      signal_error = "Invalid memory access (segmentation fault)";
      break;
    case SIGINT:
      signal_error = "External interrupt, possibly initiated by the user.";
      break;
    case SIGABRT:
      signal_error =
          "Abnormal termination condition, possible call to std::abort.";
      break;
    case SIGFPE:
      signal_error = "Erroneous arithmetic operation.";
      break;
    case SIGILL:
      signal_error = "Invalid program image or invalid instruction";
      break;
    case SIGTERM:
      signal_error = "Termination request, sent to the program.";
      break;
    default:
      signal_error = "Unknown signal thrown";
  }

  FIMSLog::fims_log->error_message(signal_error, -999, "?", "?");

  if (FIMSLog::fims_log->write_on_exit) {
    std::ofstream log(FIMSLog::fims_log->get_path());
    log << FIMSLog::fims_log->get_log();
    log.close();
  }
  std::signal(sig, SIG_DFL);
  raise(sig);
}

/**
 * Converts an object T to a string.
 *
 * @param v
 * @return
 */
template <typename T>
std::string to_string(T v) {
  std::stringstream ss;
  ss << v;
  return ss.str();
}

}  // namespace fims

#endif /* TRAITS_HPP */

/**
 * @file fims_math.hpp
 * @brief A collection of mathematical functions used in FIMS.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_MATH_HPP
#define FIMS_MATH_HPP

// note: this is modeling platform specific, must be controlled by
// preprocessing macros
#include <cmath>
#include <random>
#include <sstream>

#include "../interface/interface.hpp"
#include "fims_vector.hpp"

namespace fims_math {
#ifdef STD_LIB

/**
 * @brief The exponential function.
 *
 * @param x value to exponentiate. Please use fims_math::exp<double>(x) if x is
 * an integer.
 * @return the exponentiated value
 */
template <class Type>
inline const Type exp(const Type &x) {
  return std::exp(x);
}

/**
 * @brief The natural log function (base e)
 * @param x the value to take the log of. Please use fims_math::log<double>(x)
 * if x is an integer.
 * @return
 */
template <class Type>
inline const Type log(const Type &x) {
  return std::log(x);
}

template <class Type>
inline const Type cos(const Type &x) {
  return std::cos(x);
}

template <class Type>
inline const Type sqrt(const Type &x) {
  return std::sqrt(x);
}

template <class Type>
inline const Type pow(const Type &x, const Type &y) {
  return std::pow(x, y);
}

template <class Type>
inline const Type lgamma(const Type &x) {
  return std::lgamma(x);
}
#endif

#ifdef TMB_MODEL

// Add the following line to CMakeLists.txt to enable documentation of TMB_MODEL
// in doxygen or none of the following is rendered.
// set(DOXYGEN_PREDEFINED "TMB_MODEL=1" "ENABLE_TMB_CODE")

/**
 * @brief The exponential function for a TMB model. The function specifically
 * uses std::exp, defined in cmath header, instead of ::exp because the
 * standard library function works with TMBad library, which is designed to
 * recognize and apply its automatic differentiation capabilities to functions
 * from the standard library. Also note that this function cannot be tested
 * using the compilation flag -DTMB_MODEL through CMake and Google Test.
 * @param x The value to exponentiate. Please use fims_math::exp<double>(x) if
 * x is an integer.
 * @return The exponentiated value of x.
 */
template <class Type>
inline const Type exp(const Type &x) {
  // use std::exp for double type, look for TMB version of exp if AD type
  using std::exp;
  return exp(x);
}

/**
 * @brief The natural log function (base e) for a TMB model. The function
 * specifically uses std::log, defined in cmath header, instead of ::log
 * because the standard library function works with TMBad library, which is
 * designed to recognize and apply its automatic differentiation capabilities
 * to functions from the standard library. Also note that this function cannot
 * be tested using the compilation flag -DTMB_MODEL through CMake and Google
 * Test.
 * @param x The value to log. Please use fims_math::log<double>(x) if x is an
 * integer.
 * @return The natural log of x.
 */
template <class Type>
inline const Type log(const Type &x) {
  // use std::log for double type, look for TMB version of log if AD type
  using std::log;
  return log(x);
}

/**
 * @brief The cosine of an angle function for a TMB model. The function
 * specifically uses std::cos, defined in cmath header, instead of ::cos
 * because the standard library function works with TMBad library, which is
 * designed to recognize and apply its automatic differentiation capabilities
 * to functions from the standard library. Also note that this function cannot
 * be tested using the compilation flag -DTMB_MODEL through CMake and Google
 * Test.
 * @param x The value to take the cosine of. Please use
 * fims_math::cos<double>(x) if x is an integer.
 * @return The cosine of the angle x.
 */
template <class Type>
inline const Type cos(const Type &x) {
  // use std::cos for double type, look for TMB version of cos if AD type
  using std::cos;
  return cos(x);
}

/**
 * @brief The square root function for a TMB model. The function specifically
 * uses std::sqrt, defined in cmath header, instead of ::sqrt because the
 * standard library function works with TMBad library, which is designed to
 * recognize and apply its automatic differentiation capabilities to functions
 * from the standard library. Also note that this function cannot be tested
 * using the compilation flag -DTMB_MODEL through CMake and Google Test.
 * @param x The value to take the square root of. Please use
 * fims_math::sqrt<double>(x) if x is an integer.
 * @return The square root of x.
 */
template <class Type>
inline const Type sqrt(const Type &x) {
  // use std::std for double type, look for TMB version of std if AD type
  using std::sqrt;
  return sqrt(x);
}

/**
 * @brief The power function for a TMB model. The function specifically uses
 * std::pow, defined in cmath header, instead of ::pow because the standard
 * library function works with TMBad library, which is designed to recognize
 * and apply its automatic differentiation capabilities to functions from the
 * standard library. Also note that this function cannot be tested using the
 * compilation flag -DTMB_MODEL through CMake and Google Test.
 * @param x The value to take the power of. Please use
 * fims_math::pow<double>(x) if x is an integer.
 * @param y The exponent to raise x to.
 * @return The power of x.
 */
template <class Type>
inline const Type pow(const Type &x, const Type &y) {
  // use std::pow for double type, look for TMB version of pow if AD type
  using std::pow;
  return pow(x, y);
}

/**
 * @brief Computes the natural logarithm of the absolute value of the [gamma
 * function](https://en.wikipedia.org/wiki/Gamma_function) of x for a TMB
 * model. The function specifically uses std::lgamma, defined in cmath header,
 * instead of ::lgamma because the standard library function works with TMBad
 * library, which is designed to recognize and apply its automatic
 * differentiation capabilities to functions from the standard library. Also
 * note that this function cannot be tested using the compilation flag
 * -DTMB_MODEL through CMake and Google Test.
 * @param x The value to take the natural logarithm of the absolute value of
 * the gamma function of. Please use fims_math::lgamma<double>(x) if x is an
 * integer.
 * @return The natural logarithm of the absolute value of the gamma function of
 * x.
 */
template <class Type>
inline const Type lgamma(const Type &x) {
  // use std::lgamma for double type, look for TMB version of lgamma if AD type
  using std::lgamma;
  return lgamma(x);
}

#endif

/**
 * @brief The general logistic function
 *
 * @details
 * The logistic function can range from zero to one or one to zero, depending on
 * the slope parameter, but it is not normalized to force values to reach those
 * ranges.
 *
 * \f$ \frac{1.0}{ 1.0 + exp(-1.0 * slope (x - inflection_point))} \f$
 *
 * @param inflection_point the inflection point of the logistic function
 * @param slope the slope of the logistic function. A positive slope results in
 * an ascending logistic curve (0 to 1), while a negative slope results in a
 * descending logistic curve (1 to 0).
 * @param x the index the logistic function should be evaluated at
 * @return
 */
template <class Type>
inline const Type logistic(const Type &inflection_point, const Type &slope,
                           const Type &x) {
  return static_cast<Type>(1.0) /
         (static_cast<Type>(1.0) +
          exp(Type(-1.0) * slope * (x - inflection_point)));
}

/**
 * @brief A logit function for bounding of parameters
 *
 * \f$ -\mathrm{log}(b-x) + \mathrm{log}(x-a) \f$
 * @param a lower bound
 * @param b upper bound
 * @param x the parameter in bounded space
 * @return the parameter in real space
 *
 */
template <class Type>
inline const Type logit(const Type &a, const Type &b, const Type &x) {
  return -fims_math::log(b - x) + fims_math::log(x - a);
}

/**
 * @brief An inverse logit function for bounding of parameters
 *
 * \f$ a+\frac{b-a}{1+\mathrm{exp}(-\mathrm{logit}(x))}\f$
 * @param a lower bound
 * @param b upper bound
 * @param logit_x the parameter in real space
 * @return the parameter in bounded space
 *
 */
template <class Type>
inline const Type inv_logit(const Type &a, const Type &b, const Type &logit_x) {
  return a + (b - a) / (static_cast<Type>(1.0) + fims_math::exp(-logit_x));
}

/**
 * @brief The general double logistic function
 *
 * \f$ \frac{1.0}{ 1.0 + exp(-1.0 * slope_{asc} (x - inflection_point_{asc}))}
 * \left(1-\frac{1.0}{ 1.0 + exp(-1.0 * slope_{desc} (x -
 * inflection_point_{desc}))} \right)\f$
 *
 * @param inflection_point_asc the inflection point of the ascending limb of the
 * double logistic function
 * @param slope_asc the slope of the ascending limb of the double logistic
 * function
 * @param inflection_point_desc the inflection point of the descending limb of
 * the double logistic function, where inflection_point_desc >
 * inflection_point_asc
 * @param slope_desc the slope of the descending limb of the double logistic
 * function
 * @param x the index the logistic function should be evaluated at
 * @return
 */

template <class Type>
inline const Type double_logistic(const Type &inflection_point_asc,
                                  const Type &slope_asc,
                                  const Type &inflection_point_desc,
                                  const Type &slope_desc, const Type &x) {
  return (static_cast<Type>(1.0)) /
         (static_cast<Type>(1.0) +
          exp(Type(-1.0) * slope_asc * (x - inflection_point_asc))) *
         (static_cast<Type>(1.0) -
          (static_cast<Type>(1.0)) /
              (static_cast<Type>(1.0) +
               exp(Type(-1.0) * slope_desc * (x - inflection_point_desc))));
}

/**
 *
 * Used when x could evaluate to zero, which will result in a NaN for
 * derivative values.
 *
 * Evaluates:
 *
 * \f$ (x^2+C)^.5 \f$
 *
 * @param x value to keep positive
 * @param C default = 1e-5
 * @return
 */
template <class Type>
const Type ad_fabs(const Type &x, Type C = 1e-5) {
  return sqrt((x * x) + C);
}

/**
 *
 * Returns the minimum between a and b in a continuous manner using:
 *
 * (a + b - fims_math::ad_fabs(a - b))*.5;
 * Reference: \ref fims_math::ad_fabs()
 *
 * This is an approximation with minimal error.
 *
 * @param a
 * @param b
 * @param C default = 1e-5
 * @return
 */

template <typename Type>
inline const Type ad_min(const Type &a, const Type &b, Type C = 1e-5) {
  return (a + b - fims_math::ad_fabs(a - b, C)) * static_cast<Type>(0.5);
}

/**
 * Returns the maximum between a and b in a continuous manner using:
 *
 * (a + b + fims_math::ad_fabs(a - b)) *.5;
 * Reference: \ref fims_math::ad_fabs()
 * This is an approximation with minimal error.
 *
 * @param a
 * @param b
 * @param C default = 1e-5
 * @return
 */
template <typename Type>
inline const Type ad_max(const Type &a, const Type &b, Type C = 1e-5) {
  return (a + b + fims_math::ad_fabs(a - b, C)) * static_cast<Type>(.5);
}

/**
 * Sum elements of a vector
 *
 * @brief
 *
 * @param v A vector of constants.
 * @return A single numeric value.
 */
template <class T>
T sum(const std::vector<T> &v) {
  T ret = 0.0;
  for (size_t i = 0; i < v.size(); i++) {
    ret += v[i];
  }
  return ret;
}

/**
 * Sum elements of a vector
 *
 * @brief
 *
 * @param v A vector of constants.
 * @return A single numeric value.
 */
template <class T>
T sum(const fims::Vector<T> &v) {
  T ret = 0.0;
  for (size_t i = 0; i < v.size(); i++) {
    ret += v[i];
  }
  return ret;
}

}  // namespace fims_math

#endif /* FIMS_MATH_HPP */

/**
 * @file fims_vector.hpp
 * @brief Establishes the FIMS Vector class.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_VECTOR_HPP
#define FIMS_VECTOR_HPP

#include "../interface/interface.hpp"
#include <ostream>
#include <iomanip>

namespace fims {

/**
 * Wrapper class for std::vector types. If this file is compiled with
 * -DTMB_MODEL, conversion operators are defined for TMB vector types.
 *
 * All std::vector functions are copied over from the std library. While some of
 * these may not be called explicitly in FIMS, they may be required to run other
 * std library functions.
 *
 */
template <typename Type>
class Vector {
  std::vector<Type> vec_m;
  /**
   * @brief friend comparison operator. Allows the operator to see private
   * members of fims::Vector<Type>.
   */
  template <typename T>
  friend bool operator==(const fims::Vector<T> &lhs,
                         const fims::Vector<T> &rhs);

 public:
  // Member Types

  typedef
      typename std::vector<Type>::value_type value_type; /*!<Member type Type>*/
  typedef typename std::vector<Type>::allocator_type
      allocator_type; /*!<Allocator for type Type>*/
  typedef typename std::vector<Type>::size_type size_type; /*!<Size type>*/
  typedef typename std::vector<Type>::difference_type
      difference_type; /*!<Difference type>*/
  typedef typename std::vector<Type>::reference
      reference; /*!<Reference type &Type>*/
  typedef typename std::vector<Type>::const_reference
      const_reference; /*!<Constant reference type const &Type>*/
  typedef typename std::vector<Type>::pointer pointer; /*!<Pointer type Type*>*/
  typedef typename std::vector<Type>::const_pointer
      const_pointer; /*!<Constant pointer type const Type*>*/
  typedef typename std::vector<Type>::iterator iterator; /*!<Iterator>*/
  typedef typename std::vector<Type>::const_iterator
      const_iterator; /*!<Constant iterator>*/
  typedef typename std::vector<Type>::reverse_iterator
      reverse_iterator; /*!<Reverse iterator>*/
  typedef typename std::vector<Type>::const_reverse_iterator
      const_reverse_iterator; /*!<Constant reverse iterator>*/

  // Constructors

  /**
   * Default constructor.
   */
  Vector() {}

  /**
   * @brief Constructs a Vector of length "size" and sets the elements with the
   * value from input "value".
   */
  Vector(size_t size, const Type &value = Type()) {
    this->vec_m.resize(size, value);
  }

  /**
   * @brief Copy constructor.
   */
  Vector(const Vector<Type> &other) {
    this->vec_m.resize(other.size());
    for (size_t i = 0; i < this->vec_m.size(); i++) {
      this->vec_m[i] = other[i];
    }
  }

  /**
   * @brief Assignment operator for fims::Vector.
   *
   * @details Assigns the contents of another fims::Vector to this
   * vector. Cleans up existing contents and performs a deep copy.
   *
   * @param other The vector to assign from.
   * @return Reference to this vector.
   */
  Vector &operator=(const Vector &other) {
    if (this != &other) {
      // clean up existing
      this->~Vector();
      // copy construct into *this
      new (this) Vector(other);
    }
    return *this;
  }

  /**
   * @brief Initialization constructor from std::vector<Type> type.
   */
  Vector(const std::vector<Type> &other) { this->vec_m = other; }

  // TMB specific constructor
#ifdef TMB_MODEL

  /**
   * @brief Initialization constructor from tmbutils::vector<Type> type.
   */
  Vector(const tmbutils::vector<Type> &other) {
    this->vec_m.resize(other.size());
    for (size_t i = 0; i < this->vec_m.size(); i++) {
      this->vec_m[i] = other[i];
    }
  }

#endif

  /**
   * @brief Initialization constructor from std::initializer_list<Type> type.
   */
  Vector(std::initializer_list<Type> init) {
    this->vec_m = std::vector<Type>(init);
  }

  /**
   * The following are std::vector functions copied over from the standard
   * library. While some of these may not be called explicitly in FIMS, they may
   * be required to run other std library functions.
   */

  /**
   * @brief Returns a reference to the element at specified location pos. No
   * bounds checking is performed.
   */
  inline Type &operator[](size_t pos) {
    if (pos >= this->size()) {
      throw std::invalid_argument("fims::Vector out of bounds");
    }
    return this->vec_m[pos];
  }

  /**
   * @brief Returns a constant  reference to the element at specified location
   * pos. No bounds checking is performed.
   */
  inline const Type &operator[](size_t n) const {
    if (n >= this->size()) {
      throw std::invalid_argument("fims::Vector out of bounds");
    }
    return this->vec_m[n];
  }

  /**
   * @brief Returns a reference to the element at specified location pos. Bounds
   * checking is performed.
   */
  inline Type &at(size_t n) { return this->vec_m.at(n); }

  /**
   * @brief Returns a constant reference to the element at specified location
   * pos. Bounds checking is performed.
   */
  inline const Type &at(size_t n) const { return this->vec_m.at(n); }

  /**
   *  @brief  If this vector is size 1 and pos is greater than zero,
   * the first index is returned. If this vector has size
   * greater than 1 and pos is greater than size, a invalid_argument
   * exception is thrown. Otherwise, the value at index pos is returned.
   *
   * @param pos
   * @return a constant reference to the element at specified location
   */
  inline Type &get_force_scalar(size_t pos) {
    if (this->size() == 1 && pos > 0) {
      return this->at(0);
    } else if (this->size() > 1 && pos >= this->size()) {
      throw std::invalid_argument(
          "fims::Vector index out of bounds, check parameter sizes of input.");
    } else {
      return this->at(pos);
    }
  }

  /**
   * @brief  Returns a reference to the first element in the container.
   */
  inline reference front() { return this->vec_m.front(); }

  /**
   * @brief  Returns a constant reference to the first element in the container.
   */
  inline const_reference front() const { return this->vec_m.front(); }

  /**
   * @brief  Returns a reference to the last element in the container.
   */
  inline reference back() { return this->vec_m.back(); }

  /**
   * @brief  Returns a constant reference to the last element in the container.
   */
  inline const_reference back() const { return this->vec_m.back(); }

  /**
   * @brief Returns a pointer to the underlying data array.
   */
  inline pointer data() { return this->vec_m.data(); }

  /**
   * @brief Returns a constant pointer to the underlying data array.
   */
  inline const_pointer data() const { return this->vec_m.data(); }

  // iterators

  /**
   * @brief Returns an iterator to the first element of the vector.
   */
  inline iterator begin() { return this->vec_m.begin(); }

  /**
   * @brief Returns an iterator to the element following the last element of the
   * vector.
   */
  inline iterator end() { return this->vec_m.end(); }

  /**
   * @brief Returns a reverse iterator to the first element of the reversed
   * vector. It corresponds to the last element of the non-reversed vector.
   */
  inline reverse_iterator rbegin() { return this->vec_m.rbegin(); }

  /**
   * @brief Returns a reverse iterator to the element following the last element
   * of the reversed vector. It corresponds to the element preceding the first
   * element of the non-reversed vector.
   */
  inline reverse_iterator rend() { return this->vec_m.rend(); }

  /**
   * @brief Returns a constant reverse iterator to the first element of the
   * reversed vector. It corresponds to the last element of the non-reversed
   * vector.
   */
  inline const_reverse_iterator rbegin() const { return this->vec_m.rbegin(); }

  /**
   * @brief Returns a constant reverse iterator to the element following the
   * last element of the reversed vector. It corresponds to the element
   * preceding the first element of the non-reversed vector.
   */
  inline const_reverse_iterator rend() const { return this->vec_m.rend(); }

  // capacity

  /**
   * @brief Checks whether the container is empty.
   */
  inline bool empty() { return this->vec_m.empty(); }

  /**
   * @brief Returns the number of elements.
   */
  inline size_type size() const { return this->vec_m.size(); }

  /**
   * @brief Returns the maximum possible number of elements.
   */
  inline size_type max_size() const { return this->vec_m.max_size(); }

  /**
   * @brief Reserves storage.
   */
  inline void reserve(size_type cap) { this->vec_m.reserve(cap); }

  /**
   * @brief Returns the number of elements that can be held in currently
   * allocated storage.
   */
  inline size_type capacity() { return this->vec_m.capacity(); }

  /**
   *  @brief Reduces memory usage by freeing unused memory.
   */
  inline void shrink_to_fit() { this->vec_m.shrink_to_fit(); }

  // modifiers

  /**
   * @brief Clears the contents.
   */
  inline void clear() { this->vec_m.clear(); }

  /**
   * @brief Inserts value before pos.
   */
  inline iterator insert(const_iterator pos, const Type &value) {
    return this->vec_m.insert(pos, value);
  }

  /**
   * @brief Inserts count copies of the value before pos.
   */
  inline iterator insert(const_iterator pos, size_type count,
                         const Type &value) {
    return this->vec_m.insert(pos, count, value);
  }

  /**
   * @brief Inserts elements from range [first, last) before pos.
   */
  template <class InputIt>
  iterator insert(const_iterator pos, InputIt first, InputIt last) {
    return this->vec_m.insert(pos, first, last);
  }

  /**
   * @brief Inserts elements from initializer list ilist before pos.
   */

  iterator insert(const_iterator pos, std::initializer_list<Type> ilist) {
    return this->vec_m.insert(pos, ilist);
  }

  /**
   * @brief Constructs element in-place.
   */
  template <class... Args>
  iterator emplace(const_iterator pos, Args &&...args) {
    return this->vec_m.emplace(pos, std::forward<Args>(args)...);
  }

  /**
   * @brief Removes the element at pos.
   */
  inline iterator erase(iterator pos) { return this->vec_m.erase(pos); }

  /**
   * @brief Removes the elements in the range [first, last).
   */
  inline iterator erase(iterator first, iterator last) {
    return this->vec_m.erase(first, last);
  }

  /**
   * @brief Adds an element to the end.
   */
  inline void push_back(const Type &&value) { this->vec_m.push_back(value); }

  /**
   * @brief Constructs an element in-place at the end.
   */
  template <class... Args>
  void emplace_back(Args &&...args) {
    this->vec_m.emplace_back(std::forward<Args>(args)...);
  }

  /**
   * @brief Removes the last element.
   */
  inline void pop_back() { this->vec_m.pop_back(); }

  /**
   * @brief Changes the number of elements stored.
   */
  inline void resize(size_t s) { this->vec_m.resize(s); }

  /**
   * @brief Swaps the contents.
   */
  inline void swap(Vector &other) { this->vec_m.swap(other.vec_m); }

  // end std::vector functions

  /**
   * Conversion operators
   */

  /**
   * @brief Converts fims::Vector<Type> to std::vector<Type>
   */
  inline operator std::vector<Type>() { return this->vec_m; }

#ifdef TMB_MODEL

  /**
   * @brief Converts fims::Vector<Type> to tmbutils::vector<Type>
   *
   * We provide both:
   *  1. An explicit conversion operator (requires static_cast)
   *  2. A named method `to_tmb()` for clarity
   */
  explicit operator tmbutils::vector<Type>() const {
    tmbutils::vector<Type> ret(this->vec_m.size());
    for (size_t i = 0; i < this->vec_m.size(); i++) {
      ret[i] = this->vec_m[i];
    }
    return ret;
  }

  /**
   * @brief Converts fims::Vector<Type> to tmbutils::vector<Type>
   */
  tmbutils::vector<Type> to_tmb() const {
    tmbutils::vector<Type> ret(this->vec_m.size());
    for (size_t i = 0; i < this->vec_m.size(); i++) {
      ret[i] = this->vec_m[i];
    }
    return ret;
  }

  /**
   * @brief Converts fims::Vector<Type> to tmbutils::vector<Type>
   *
   * We provide both:
   *  1. An explicit conversion operator (requires static_cast)
   *  2. A named method `to_tmb()` for clarity
   */
  explicit operator tmbutils::vector<Type>() {
    tmbutils::vector<Type> ret(this->vec_m.size());
    for (size_t i = 0; i < this->vec_m.size(); i++) {
      ret[i] = this->vec_m[i];
    }
    return ret;
  }

  /**
   * @brief Converts fims::Vector<Type> to tmbutils::vector<Type>
   */
  tmbutils::vector<Type> to_tmb() {
    tmbutils::vector<Type> ret(this->vec_m.size());
    for (size_t i = 0; i < this->vec_m.size(); i++) {
      ret[i] = this->vec_m[i];
    }
    return ret;
  }

#else

  /**
   * @brief Convert fims::Vector to std::vector.
   *
   * @details Returns a standard vector containing the same elements
   * as the fims::Vector.
   *
   * @return std::vector<Type> with the same elements.
   */
  std::vector<Type> to_std() const { return this->vec_m; }

  /**
   * @brief Convert fims::Vector to TMB vector type.
   *
   * @details Returns a TMB-compatible vector containing the same
   * elements as the fims::Vector. Only available if compiled with
   * TMB_MODEL.
   *
   * @return TMB vector type with the same elements.
   */
  std::vector<Type> to_tmb() const { return this->vec_m; }
#endif

  /**
   * @brief Gets the tag for the vector. A tag can represent anything
   * and is not used internally by FIMS.
   * @return The tag.
   */
  std::string get_tag() const { return this->tag_m; }
  /**
   * @brief Sets the tag for the vector. A tag can be set to
   * any string value and is not used internally by FIMS.
   */
  void set_tag(const std::string &tag) { this->tag_m = tag; }

 private:
  std::string tag_m; /*!< The tag for the vector. */
};  // end fims::Vector class

/**
 * @brief Comparison operator.
 */
template <class T>
bool operator==(const fims::Vector<T> &lhs, const fims::Vector<T> &rhs) {
  return lhs.vec_m == rhs.vec_m;
}

}  // namespace fims

/**
 * @brief Output for std::ostream& for a vector.
 *
 * @param out The stream.
 * @param v A vector.
 * @return std::ostream&
 */
template <typename Type>
std::ostream &operator<<(std::ostream &out, const fims::Vector<Type> &v) {
  out << std::fixed << std::setprecision(10);
  out << "[";

  if (v.size() == 0) {
    out << "]";
    return out;
  }
  for (size_t i = 0; i < v.size() - 1; i++) {
    if (v[i] != v[i]) {
      out << "-999" << ",";
    } else {
      out << v[i] << ",";
    }
  }
  if (v[v.size() - 1] != v[v.size() - 1]) {
    out << "-999]";
  } else {
    out << v[v.size() - 1] << "]";
  }
  return out;
}

#endif

/**
 * @file information.hpp
 * @brief Code to store all objects that are created in FIMS because FIMS uses
 * integer representation. Code loops over all model components and sets them
 * up based on unique identifiers.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */

#ifndef FIMS_COMMON_INFORMATION_HPP
#define FIMS_COMMON_INFORMATION_HPP

#include <algorithm>
#include <map>
#include <memory>
#include <vector>

#include "../distributions/distributions.hpp"
#include "../models/functors/fishery_model_base.hpp"
#include "../population_dynamics/fleet/fleet.hpp"
#include "../population_dynamics/growth/growth.hpp"
#include "../population_dynamics/population/population.hpp"
#include "../population_dynamics/recruitment/recruitment.hpp"
#include "../population_dynamics/selectivity/selectivity.hpp"
#include "def.hpp"
#include "fims_vector.hpp"
#include "model_object.hpp"

namespace fims_info {

/**
 * @brief Stores FIMS model information and creates model. Contains all objects
 * and data pre-model construction
 */
template <typename Type>
class Information {
 public:
  size_t n_years = 0; /**< number of years >*/
  size_t n_ages = 0;  /**< number of ages>*/

  static std::shared_ptr<Information<Type>>
      fims_information;          /**< singleton instance >*/
  std::vector<Type*> parameters; /**< list of all estimated parameters >*/
  std::vector<Type*>
      random_effects_parameters; /**< list of all random effects parameters >*/
  std::vector<Type*>
      fixed_effects_parameters; /**< list of all fixed effects parameters >*/
  std::vector<std::string> parameter_names; /**< list of all parameter names
                                               estimated in the model */
  std::vector<std::string>
      random_effects_names; /**< list of all random effects names estimated in
                               the model */

  // data objects
  std::map<uint32_t, std::shared_ptr<fims_data_object::DataObject<Type>>>
      data_objects; /**< map that holds data objects >*/
  typedef typename std::map<
      uint32_t, std::shared_ptr<fims_data_object::DataObject<Type>>>::iterator
      data_iterator; /**< iterator for the data objects */

  // life history modules
  std::map<uint32_t, std::shared_ptr<fims_popdy::RecruitmentBase<Type>>>
      recruitment_models; /**<hash map to link each object to its shared
                           location in memory*/
  typedef typename std::map<
      uint32_t, std::shared_ptr<fims_popdy::RecruitmentBase<Type>>>::iterator
      recruitment_models_iterator;
  /**< iterator for recruitment objects>*/

  std::map<uint32_t, std::shared_ptr<fims_popdy::RecruitmentBase<Type>>>
      recruitment_process_models; /**<hash map to link each object to its shared
                           location in memory*/
  typedef typename std::map<
      uint32_t, std::shared_ptr<fims_popdy::RecruitmentBase<Type>>>::iterator
      recruitment_process_iterator;
  /**< iterator for recruitment process objects>*/

  std::map<uint32_t, std::shared_ptr<fims_popdy::SelectivityBase<Type>>>
      selectivity_models; /**<hash map to link each object to its shared
                           location in memory*/
  typedef typename std::map<
      uint32_t, std::shared_ptr<fims_popdy::SelectivityBase<Type>>>::iterator
      selectivity_models_iterator;
  /**< iterator for selectivity objects>*/

  std::map<uint32_t, std::shared_ptr<fims_popdy::GrowthBase<Type>>>
      growth_models; /**<hash map to link each object to its shared location in
                      memory*/
  typedef
      typename std::map<uint32_t,
                        std::shared_ptr<fims_popdy::GrowthBase<Type>>>::iterator
          growth_models_iterator;
  /**< iterator for growth objects>*/

  std::map<uint32_t, std::shared_ptr<fims_popdy::MaturityBase<Type>>>
      maturity_models; /**<hash map to link each object to its shared location
                        in memory*/
  typedef typename std::map<
      uint32_t, std::shared_ptr<fims_popdy::MaturityBase<Type>>>::iterator
      maturity_models_iterator;
  /**< iterator for maturity objects>*/

  // fleet modules
  std::map<uint32_t, std::shared_ptr<fims_popdy::Fleet<Type>>>
      fleets; /**<hash map to link each object to its shared location in
               memory*/
  typedef typename std::map<uint32_t,
                            std::shared_ptr<fims_popdy::Fleet<Type>>>::iterator
      fleet_iterator;
  /**< iterator for fleet objects>*/

  // populations
  std::map<uint32_t, std::shared_ptr<fims_popdy::Population<Type>>>
      populations; /**<hash map to link each object to its shared location in
                    memory*/
  typedef
      typename std::map<uint32_t,
                        std::shared_ptr<fims_popdy::Population<Type>>>::iterator
          population_iterator;
  /**< iterator for population objects>*/

  // distributions
  std::map<uint32_t,
           std::shared_ptr<fims_distributions::DensityComponentBase<Type>>>
      density_components; /**<hash map to link each object to its shared
                            location in memory*/
  typedef typename std::map<
      uint32_t,
      std::shared_ptr<fims_distributions::DensityComponentBase<Type>>>::iterator
      density_components_iterator;
  /**< iterator for distribution objects>*/

  std::unordered_map<uint32_t,
                     std::shared_ptr<fims_popdy::FisheryModelBase<Type>>>
      models_map; /**<hash map of fishery models, e.g., CAA, GMACS, Spatial,
                     etc*/
  typedef typename std::unordered_map<
      uint32_t, std::shared_ptr<fims_popdy::FisheryModelBase<Type>>>::iterator
      model_map_iterator; /**< iterator for variable map>*/

  std::unordered_map<uint32_t, fims::Vector<Type>*>
      variable_map; /**<hash map to link a parameter, derived value, or
                      observation to its shared location in memory */
  typedef typename std::unordered_map<uint32_t, fims::Vector<Type>*>::iterator
      variable_map_iterator; /**< iterator for variable map>*/

  Information() {}

  virtual ~Information() {}

  /**
   * @brief Clears all containers.
   *
   */
  void Clear() {
    this->data_objects.clear();
    this->populations.clear();
    this->fixed_effects_parameters.clear();
    this->fleets.clear();
    this->growth_models.clear();
    this->maturity_models.clear();
    this->parameter_names.clear();
    this->parameters.clear();
    this->random_effects_names.clear();
    this->random_effects_parameters.clear();
    this->recruitment_models.clear();
    this->recruitment_process_models.clear();
    this->selectivity_models.clear();
    this->models_map.clear();
    this->n_years = 0;
    this->n_ages = 0;

    for (density_components_iterator it = density_components.begin();
         it != density_components.end(); ++it) {
      std::shared_ptr<fims_distributions::DensityComponentBase<Type>> d =
          (*it).second;
      if ((d->priors)[0] != NULL) {
        d->priors.clear();
      }
      if (d->data_expected_values != NULL) {
        d->data_expected_values->clear();
      }
      if (d->re != NULL) {
        d->re->clear();
      }
      if (d->re_expected_values != NULL) {
        d->re_expected_values->clear();
      }
    }
    this->density_components.clear();
  }

  /**
   * @brief Get a summary string of the Information object state.
   *
   * @details Returns a string containing the sizes and states of all major
   * containers and model components in the Information object. Useful for
   * debugging and diagnostics.
   *
   * @return std::string summary of the Information object state.
   */
  std::string State() {
    std::stringstream ss;
    ss << "Information object State:\n";
    ss << "data_objects: " << this->data_objects.clear();
    ss << "populations: " << this->populations.size() << std::endl;
    ss << "fixed_effects_parameters: " << this->fixed_effects_parameters.size()
       << std::endl;
    ss << "fleets: " << this->fleets.size() << std::endl;
    ss << "growth_models: " << this->growth_models.size() << std::endl;
    ss << "maturity_models: " << this->maturity_models.size() << std::endl;
    ss << "parameter_names: " << this->parameter_names.size() << std::endl;
    ss << "parameters: " << this->parameters.size() << std::endl;
    ss << "random_effects_names: " << this->random_effects_names.size()
       << std::endl;
    ss << "random_effects_parameters: "
       << this->random_effects_parameters.size() << std::endl;
    ss << "recruitment_models: " << this->recruitment_models.size()
       << std::endl;
    ss << "recruitment_process_models: "
       << this->recruitment_process_models.size() << std::endl;
    ss << "selectivity_models: " << this->selectivity_models.size()
       << std::endl;
    ss << "models_map: " << this->models_map.size() << std::endl;
    ss << "n_years: " << this->n_years << std::endl;
    ss << "n_ages: " << this->n_ages << std::endl;
    ss << "density_components: " << this->density_components.size()
       << std::endl;
    return ss.str();
  }

  /**
   * @brief Returns a singleton Information object for type T.
   *
   * @return singleton for type T
   */
  static std::shared_ptr<Information<Type>> GetInstance() {
    if (Information<Type>::fims_information == nullptr) {
      Information<Type>::fims_information =
          std::make_shared<fims_info::Information<Type>>();
    }
    return Information<Type>::fims_information;
  }

  /**
   * @brief Register a parameter as estimable.
   *
   * @param p parameter
   */
  void RegisterParameter(Type& p) {
    this->fixed_effects_parameters.push_back(&p);
  }

  /**
   * @brief Register a random effect as estimable.
   *
   * @param re random effect
   */
  void RegisterRandomEffect(Type& re) {
    this->random_effects_parameters.push_back(&re);
  }

  /**
   * @brief Register a parameter name.
   *
   * @param p_name parameter name
   */
  void RegisterParameterName(std::string p_name) {
    this->parameter_names.push_back(p_name);
  }

  /**
   * @brief Register a random effects name.
   *
   * @param re_name random effects name
   */
  void RegisterRandomEffectName(std::string re_name) {
    this->random_effects_names.push_back(re_name);
  }

  /**
   * @brief Loop over distributions and set links to distribution x value if
   * distribution is a prior type.
   */
  void SetupPriors() {
    for (density_components_iterator it = density_components.begin();
         it != density_components.end(); ++it) {
      std::shared_ptr<fims_distributions::DensityComponentBase<Type>> d =
          (*it).second;
      if (d->input_type == "prior") {
        FIMS_INFO_LOG("Setup prior for distribution " + fims::to_string(d->id));
        variable_map_iterator vmit;
        FIMS_INFO_LOG("Link prior from distribution " + fims::to_string(d->id) +
                      " to parameter " + fims::to_string(d->key[0]));
        d->priors.resize(d->key.size());
        for (size_t i = 0; i < d->key.size(); i++) {
          FIMS_INFO_LOG("Link prior from distribution " +
                        fims::to_string(d->id) + " to parameter " +
                        fims::to_string(d->key[0]));
          vmit = this->variable_map.find(d->key[i]);
          d->priors[i] = (*vmit).second;
        }
        FIMS_INFO_LOG("Prior size for distribution " + fims::to_string(d->id) +
                      "is: " + fims::to_string(d->observed_values.size()));
      }
    }
  }

  /**
   * @brief Loop over distributions and set links to distribution x value if
   * distribution is a random effects type.
   */
  void SetupRandomEffects() {
    for (density_components_iterator it = this->density_components.begin();
         it != this->density_components.end(); ++it) {
      std::shared_ptr<fims_distributions::DensityComponentBase<Type>> d =
          (*it).second;
      if (d->input_type == "random_effects") {
        FIMS_INFO_LOG("Setup random effects for distribution " +
                      fims::to_string(d->id));
        variable_map_iterator vmit;
        FIMS_INFO_LOG("Link random effects from distribution " +
                      fims::to_string(d->id) + " to derived value " +
                      fims::to_string(d->key[0]));
        vmit = this->variable_map.find(d->key[0]);
        d->re = (*vmit).second;
        if (d->key.size() == 2) {
          vmit = this->variable_map.find(d->key[1]);
          d->re_expected_values = (*vmit).second;
        } else {
          d->re_expected_values = &d->expected_values;
        }
        FIMS_INFO_LOG("Random effect size for distribution " +
                      fims::to_string(d->id) +
                      " is: " + fims::to_string(d->observed_values.size()));
      }
    }
  }

  /**
   * @brief Loop over distributions and set links to distribution expected value
   * if distribution is a data type.
   */
  void SetupData() {
    for (density_components_iterator it = this->density_components.begin();
         it != this->density_components.end(); ++it) {
      std::shared_ptr<fims_distributions::DensityComponentBase<Type>> d =
          (*it).second;
      if (d->input_type == "data") {
        FIMS_INFO_LOG("Setup expected value for data distribution " +
                      fims::to_string(d->id));
        variable_map_iterator vmit;
        FIMS_INFO_LOG("Link expected value from distribution " +
                      fims::to_string(d->id) + " to derived value " +
                      fims::to_string(d->key[0]));
        vmit = this->variable_map.find(d->key[0]);
        d->data_expected_values = (*vmit).second;
        FIMS_INFO_LOG(
            "Expected value size for distribution " + fims::to_string(d->id) +
            " is: " + fims::to_string((*d->data_expected_values).size()));
      }
    }
  }

  /**
   * @brief Set pointers to landings data in the fleet module.
   *
   * @param &valid_model reference to true/false boolean indicating whether
   * model is valid.
   * @param f shared pointer to fleet module
   */
  void SetFleetLandingsData(bool& valid_model,
                            std::shared_ptr<fims_popdy::Fleet<Type>> f) {
    if (f->fleet_observed_landings_data_id_m != static_cast<Type>(-999)) {
      uint32_t observed_landings_id =
          static_cast<uint32_t>(f->fleet_observed_landings_data_id_m);
      data_iterator it = this->data_objects.find(observed_landings_id);
      if (it != this->data_objects.end()) {
        f->observed_landings_data = (*it).second;
        FIMS_INFO_LOG("Landings data for fleet " + fims::to_string(f->id) +
                      " successfully set to " +
                      fims::to_string(f->observed_landings_data->at(1)));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG("Expected landings data not defined for fleet " +
                       fims::to_string(f->id) + ", index " +
                       fims::to_string(observed_landings_id));
      }
    }
  }

  /**
   * @brief Set pointers to index data in the fleet module.
   *
   * @param &valid_model reference to true/false boolean indicating whether
   * model is valid.
   * @param f shared pointer to fleet module
   */
  void SetFleetIndexData(bool& valid_model,
                         std::shared_ptr<fims_popdy::Fleet<Type>> f) {
    if (f->fleet_observed_index_data_id_m != static_cast<Type>(-999)) {
      uint32_t observed_index_id =
          static_cast<uint32_t>(f->fleet_observed_index_data_id_m);
      data_iterator it = this->data_objects.find(observed_index_id);
      if (it != this->data_objects.end()) {
        f->observed_index_data = (*it).second;
        FIMS_INFO_LOG("Index data for fleet " + fims::to_string(f->id) +
                      " successfully set to " +
                      fims::to_string(f->observed_index_data->at(1)));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG("Expected index data not defined for fleet " +
                       fims::to_string(f->id) + ", index " +
                       fims::to_string(observed_index_id));
      }
    }
  }

  /**
   * @brief Set pointers to age composition data in the fleet module.
   *
   * @param &valid_model reference to true/false boolean indicating whether
   * model is valid.
   * @param f shared pointer to fleet module
   */
  void SetAgeCompositionData(bool& valid_model,
                             std::shared_ptr<fims_popdy::Fleet<Type>> f) {
    if (f->fleet_observed_agecomp_data_id_m != static_cast<Type>(-999)) {
      uint32_t observed_agecomp_id =
          static_cast<uint32_t>(f->fleet_observed_agecomp_data_id_m);
      data_iterator it = this->data_objects.find(observed_agecomp_id);
      if (it != this->data_objects.end()) {
        f->observed_agecomp_data = (*it).second;
        FIMS_INFO_LOG("Observed input age-composition data for fleet " +
                      fims::to_string(f->id) + " successfully set to " +
                      fims::to_string(f->observed_agecomp_data->at(1)));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG(
            "Expected age-composition observations not defined for fleet " +
            fims::to_string(f->id));
      }
    }
  }

  /**
   * @brief Set pointers to length composition data in the fleet module.
   *
   * @param &valid_model reference to true/false boolean indicating whether
   * model is valid.
   * @param f shared pointer to fleet module
   */
  void SetLengthCompositionData(bool& valid_model,
                                std::shared_ptr<fims_popdy::Fleet<Type>> f) {
    if (f->fleet_observed_lengthcomp_data_id_m != static_cast<Type>(-999)) {
      uint32_t observed_lengthcomp_id =
          static_cast<uint32_t>(f->fleet_observed_lengthcomp_data_id_m);
      data_iterator it = this->data_objects.find(observed_lengthcomp_id);
      if (it != this->data_objects.end()) {
        f->observed_lengthcomp_data = (*it).second;
        FIMS_INFO_LOG("Observed input length-composition data for fleet " +
                      fims::to_string(f->id) + " successfully set to " +
                      fims::to_string(f->observed_lengthcomp_data->at(1)));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG(
            "Expected length-composition observations not defined for fleet " +
            fims::to_string(f->id));
      }
    }
  }

  /**
   * @brief Set pointers to the selectivity module referenced in the fleet
   * module.
   *
   * @param &valid_model reference to true/false boolean indicating whether
   * model is valid.
   * @param f shared pointer to fleet module
   */
  void SetFleetSelectivityModel(bool& valid_model,
                                std::shared_ptr<fims_popdy::Fleet<Type>> f) {
    if (f->fleet_selectivity_id_m != static_cast<Type>(-999)) {
      uint32_t sel_id = static_cast<uint32_t>(
          f->fleet_selectivity_id_m);  // cast as unsigned integer
      selectivity_models_iterator it = this->selectivity_models.find(
          sel_id);  // if find, set it, otherwise invalid

      if (it != this->selectivity_models.end()) {
        f->selectivity = (*it).second;  // elements in container held in pair
        FIMS_INFO_LOG("Selectivity model " +
                      fims::to_string(f->fleet_selectivity_id_m) +
                      " successfully set to fleet " + fims::to_string(f->id));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG("Expected selectivity pattern not defined for fleet " +
                       fims::to_string(f->id) + ", selectivity pattern " +
                       fims::to_string(sel_id));
      }
    } else {
      FIMS_WARNING_LOG("Warning: No selectivity pattern defined for fleet " +
                       fims::to_string(f->id) +
                       ". FIMS requires selectivity be defined for all fleets "
                       "when running a catch at age model.");
    }
  }

  /**
   * @brief Set pointers to the recruitment module referenced in the population
   * module.
   *
   * @param &valid_model reference to true/false boolean indicating whether
   * model is valid.
   * @param p shared pointer to population module
   */
  void SetRecruitment(bool& valid_model,
                      std::shared_ptr<fims_popdy::Population<Type>> p) {
    if (p->recruitment_id != static_cast<Type>(-999)) {
      uint32_t recruitment_uint = static_cast<uint32_t>(p->recruitment_id);
      FIMS_INFO_LOG("searching for recruitment model " +
                    fims::to_string(recruitment_uint));
      recruitment_models_iterator it =
          this->recruitment_models.find(recruitment_uint);

      if (it != this->recruitment_models.end()) {
        p->recruitment = (*it).second;  // recruitment defined in population.hpp
        FIMS_INFO_LOG("Recruitment model " + fims::to_string(recruitment_uint) +
                      " successfully set to population " +
                      fims::to_string(p->id));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG(
            "Expected recruitment function not defined for "
            "population " +
            fims::to_string(p->id) + ", recruitment function " +
            fims::to_string(recruitment_uint));
      }
    } else {
      FIMS_WARNING_LOG(
          "No recruitment function defined for population " +
          fims::to_string(p->id) +
          ". FIMS requires recruitment functions be defined for all "
          "populations when running a catch at age model.");
    }
  }

  /**
   * @brief Set pointers to the recruitment process module referenced in the
   * population module.
   *
   * @param &valid_model reference to true/false boolean indicating whether
   * model is valid.
   * @param p shared pointer to population module
   */
  void SetRecruitmentProcess(bool& valid_model,
                             std::shared_ptr<fims_popdy::Population<Type>> p) {
    std::shared_ptr<fims_popdy::RecruitmentBase<Type>> r = p->recruitment;
    // if recruitment is defined
    if (r) {
      if (r->process_id != static_cast<Type>(-999)) {
        uint32_t process_uint = static_cast<uint32_t>(r->process_id);
        recruitment_process_iterator it =
            this->recruitment_process_models.find(process_uint);

        if (it != this->recruitment_process_models.end()) {
          r->process = (*it).second;  // recruitment process
          FIMS_INFO_LOG(
              "Recruitment Process model " + fims::to_string(process_uint) +
              " successfully set to population " + fims::to_string(p->id));
          (*it).second->recruitment = r;
        } else {
          valid_model = false;
          FIMS_ERROR_LOG(
              "Expected recruitment process function not defined for "
              "population " +
              fims::to_string(p->id) + ", recruitment process function " +
              fims::to_string(process_uint));
        }
      } else {
        FIMS_WARNING_LOG(
            "No recruitment process function defined for population " +
            fims::to_string(p->id) +
            ". FIMS requires recruitment process functions be defined for all "
            "recruitments when running a catch at age model.");
      }
    }
  }

  /**
   * @brief Set pointers to the growth module referenced in the population
   * module.
   *
   * @param &valid_model reference to true/false boolean indicating whether
   * model is valid.
   * @param p shared pointer to population module
   */
  void SetGrowth(bool& valid_model,
                 std::shared_ptr<fims_popdy::Population<Type>> p) {
    if (p->growth_id != static_cast<Type>(-999)) {
      uint32_t growth_uint = static_cast<uint32_t>(p->growth_id);
      growth_models_iterator it = this->growth_models.find(
          growth_uint);  // growth_models is specified in information.hpp
      // and used in rcpp
      // at the head of information.hpp; are the
      // dimensions of ages defined in rcpp or where?
      if (it != this->growth_models.end()) {
        p->growth =
            (*it).second;  // growth defined in population.hpp (the object
        // is called p, growth is within p)
        FIMS_INFO_LOG("Growth model " + fims::to_string(growth_uint) +
                      " successfully set to population " +
                      fims::to_string(p->id));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG("Expected growth function not defined for population " +
                       fims::to_string(p->id) + ", growth function " +
                       fims::to_string(growth_uint));
      }
    } else {
      FIMS_WARNING_LOG("No growth function defined for population " +
                       fims::to_string(p->id) +
                       ". FIMS requires growth functions be defined for all "
                       "populations when running a catch at age model.");
    }
  }

  /**
   * @brief Set pointers to the maturity module referenced in the population
   * module.
   *
   * @param &valid_model reference to true/false boolean indicating whether
   * model is valid.
   * @param p shared pointer to population module
   */
  void SetMaturity(bool& valid_model,
                   std::shared_ptr<fims_popdy::Population<Type>> p) {
    if (p->maturity_id != static_cast<Type>(-999)) {
      uint32_t maturity_uint = static_cast<uint32_t>(p->maturity_id);
      maturity_models_iterator it = this->maturity_models.find(
          maturity_uint);  // >maturity_models is specified in
      // information.hpp and used in rcpp
      if (it != this->maturity_models.end()) {
        p->maturity = (*it).second;  // >maturity defined in population.hpp
        FIMS_INFO_LOG("Maturity model " + fims::to_string(maturity_uint) +
                      " successfully set to population " +
                      fims::to_string(p->id));
      } else {
        valid_model = false;
        FIMS_ERROR_LOG(
            "Expected maturity function not defined for population " +
            fims::to_string(p->id) + ", maturity function " +
            fims::to_string(maturity_uint));
      }
    } else {
      FIMS_WARNING_LOG("No maturity function defined for population " +
                       fims::to_string(p->id) +
                       ". FIMS requires maturity functions be defined for all "
                       "populations when running a catch at age model.");
    }
  }

  /**
   * @brief Loop over all fleets and set pointers to fleet objects
   *
   * @param &valid_model reference to true/false boolean indicating whether
   * model is valid.
   */
  void CreateFleetObjects(bool& valid_model) {
    for (fleet_iterator it = this->fleets.begin(); it != this->fleets.end();
         ++it) {
      std::shared_ptr<fims_popdy::Fleet<Type>> f = (*it).second;
      FIMS_INFO_LOG("Initializing fleet " + fims::to_string(f->id));

      SetFleetLandingsData(valid_model, f);

      SetFleetIndexData(valid_model, f);

      SetAgeCompositionData(valid_model, f);

      SetLengthCompositionData(valid_model, f);

      SetFleetSelectivityModel(valid_model, f);
    }
  }

  /**
   * @brief Loop over all density components and set pointers to data objects
   *
   * @param &valid_model reference to true/false boolean indicating whether
   * model is valid.
   */
  void SetDataObjects(bool& valid_model) {
    for (density_components_iterator it = this->density_components.begin();
         it != this->density_components.end(); ++it) {
      std::shared_ptr<fims_distributions::DensityComponentBase<Type>> d =
          (*it).second;

      // set data objects if distribution is a data type
      if (d->input_type == "data") {
        if (d->observed_data_id_m != static_cast<Type>(-999)) {
          uint32_t observed_data_id =
              static_cast<uint32_t>(d->observed_data_id_m);
          data_iterator it = this->data_objects.find(observed_data_id);

          if (it != this->data_objects.end()) {
            d->data_observed_values = (*it).second;
            FIMS_INFO_LOG("Observed data " + fims::to_string(observed_data_id) +
                          " successfully set to density component " +
                          fims::to_string(d->id));
          } else {
            valid_model = false;
            FIMS_ERROR_LOG(
                "Expected data observations not defined for density "
                "component " +
                fims::to_string(d->id) + ", observed data " +
                fims::to_string(observed_data_id));
          }
        } else {
          valid_model = false;
          FIMS_ERROR_LOG("No data input for density component" +
                         fims::to_string(d->id));
        }
      }
    }
  }

  /**
   * @brief Loop over all populations and set pointers to population objects
   *
   * @param &valid_model reference to true/false boolean indicating whether
   * model is valid.
   */
  void CreatePopulationObjects(bool& valid_model) {
    for (population_iterator it = this->populations.begin();
         it != this->populations.end(); ++it) {
      std::shared_ptr<fims_popdy::Population<Type>> p = (*it).second;

      FIMS_INFO_LOG("Initializing population " + fims::to_string(p->id));
      // check if population has fleets
      typename std::set<uint32_t>::iterator fleet_ids_it;

      for (fleet_ids_it = p->fleet_ids.begin();
           fleet_ids_it != p->fleet_ids.end(); ++fleet_ids_it) {
        // error check and set population elements
        // check me - add another fleet iterator to push information from
        //  for (fleet_iterator it = this->fleets.begin(); it !=
        //  this->fleets.end();
        //        ++it) {

        fleet_iterator it = this->fleets.find(*fleet_ids_it);

        if (it != this->fleets.end()) {
          // Initialize fleet object
          std::shared_ptr<fims_popdy::Fleet<Type>> f = (*it).second;
          // population to the individual fleets This is to pass catch at age
          // from population to fleets?
          // any shared member in p (population is pushed into fleets)
          p->fleets.push_back(f);
        } else {
          valid_model = false;
          FIMS_ERROR_LOG("Fleet \"" + fims::to_string(*fleet_ids_it) +
                         "\" undefined, not found for Population \"" +
                         fims::to_string(p->id) + "\". ");
        }
        // // error check and set population elements
        // // check me - add another fleet iterator to push information from
        // for (fleet_iterator it = this->fleets.begin(); it !=
        // this->fleets.end();
        //      ++it)
        // {
        //     // Initialize fleet object
        //     std::shared_ptr<fims_popdy::Fleet<Type>> f = (*it).second;
        //     // population to the individual fleets This is to pass landings
        //     at age
        //     // from population to fleets?
        //     // any shared member in p (population is pushed into fleets)
        //     p->fleets.push_back(f);
        // }
      }

      // set information dimensions
      this->n_years = std::max(this->n_years, p->n_years);
      this->n_ages = std::max(this->n_ages, p->n_ages);

      SetRecruitment(valid_model, p);

      SetRecruitmentProcess(valid_model, p);

      SetGrowth(valid_model, p);

      SetMaturity(valid_model, p);
    }
  }

  /**
   * @brief Loop over all models and set pointers to population objects
   */
  void CreateModelingObjects(bool& valid_model) {
    for (model_map_iterator it = this->models_map.begin();
         it != this->models_map.end(); ++it) {
      std::shared_ptr<fims_popdy::FisheryModelBase<Type>>& model = (*it).second;
      std::set<uint32_t>::iterator jt;

      for (jt = model->population_ids.begin();
           jt != model->population_ids.end(); ++jt) {
        population_iterator pt = this->populations.find((*jt));

        if (pt != this->populations.end()) {
          std::shared_ptr<fims_popdy::Population<Type>> p = (*pt).second;
          model->populations.push_back(p);
          for (size_t i = 0; i < p->fleets.size(); i++) {
            model->fleets[p->fleets[i]->GetId()] = p->fleets[i];
          }
        } else {
          valid_model = false;
          FIMS_ERROR_LOG("No population object defined for model " +
                         fims::to_string(model->GetId()));
        }
      }
      model->Initialize();
    }
  }

  /**
   * @brief Create the generalized stock assessment model that will evaluate the
   * objective function. Does error checking to make sure the program has
   * all necessary components for the model and that they're in the right
   * dimensions. This sets up pointers to all memory objects and initializes
   * fleet and population objects.
   *
   * @return True if valid model, False if invalid model, check fims.log for
   * errors.
   */
  bool CreateModel() {
    bool valid_model = true;

    CreateFleetObjects(valid_model);

    SetDataObjects(valid_model);

    CreatePopulationObjects(valid_model);

    CreateModelingObjects(valid_model);

    // setup priors, random effect, and data density components
    SetupPriors();
    SetupRandomEffects();
    SetupData();

    return valid_model;
  }

  /**
   * @brief Get the Nages object
   *
   * @return size_t
   */
  size_t GetNages() const { return n_ages; }

  /**
   * @brief Set the Nages object
   *
   * @param n_ages
   */
  void SetNages(size_t n_ages) { this->n_ages = n_ages; }

  /**
   * @brief Get the n_years object
   *
   * @return size_t
   */
  size_t GetNyears() const { return n_years; }

  /**
   * @brief Set the n_years object
   *
   * @param n_years
   */
  void SetNyears(size_t n_years) { this->n_years = n_years; }

  /**
   * @brief Get the Parameters object
   *
   * @return std::vector<Type*>&
   */
  std::vector<Type*>& GetParameters() { return parameters; }

  /**
   * @brief Get the Fixed Effects Parameters object
   *
   * @return std::vector<Type*>&
   */
  std::vector<Type*>& GetFixedEffectsParameters() {
    return fixed_effects_parameters;
  }

  /**
   * @brief Get the Random Effects Parameters object
   *
   * @return std::vector<Type*>&
   */
  std::vector<Type*>& GetRandomEffectsParameters() {
    return random_effects_parameters;
  }

  /**
   * @brief Checks to make sure all required modules are present for specified
   * model
   *
   * @return True if valid model, False if invalid model, check fims.log for
   * errors.
   */
  bool CheckModel() {
    bool valid_model = true;
    for (model_map_iterator it = this->models_map.begin();
         it != this->models_map.end(); ++it) {
      std::shared_ptr<fims_popdy::FisheryModelBase<Type>>& model = (*it).second;
      std::set<uint32_t>::iterator jt;

      for (jt = model->population_ids.begin();
           jt != model->population_ids.end(); ++jt) {
        population_iterator pt = this->populations.find((*jt));

        if (pt != this->populations.end()) {
          std::shared_ptr<fims_popdy::Population<Type>> p = (*pt).second;

          if (model->model_type_m == "caa") {
            typename std::set<uint32_t>::iterator fleet_ids_it;
            for (fleet_ids_it = p->fleet_ids.begin();
                 fleet_ids_it != p->fleet_ids.end(); ++fleet_ids_it) {
              fleet_iterator it = this->fleets.find(*fleet_ids_it);

              if (it != this->fleets.end()) {
                // Initialize fleet object
                std::shared_ptr<fims_popdy::Fleet<Type>> f = (*it).second;

                if (f->fleet_selectivity_id_m == static_cast<Type>(-999)) {
                  valid_model = false;
                  FIMS_ERROR_LOG(
                      "No selectivity pattern defined for fleet " +
                      fims::to_string(f->id) +
                      ". FIMS requires selectivity be defined for all fleets "
                      "when running a catch at age model.");
                }
              }
            }

            if (p->recruitment_id == static_cast<Type>(-999)) {
              valid_model = false;
              FIMS_ERROR_LOG(
                  "No recruitment function defined for population " +
                  fims::to_string(p->id) +
                  ". FIMS requires recruitment functions be defined for all "
                  "populations when running a catch at age model.");
            }

            std::shared_ptr<fims_popdy::RecruitmentBase<Type>> r =
                p->recruitment;
            r = p->recruitment;
            if (r->process_id == static_cast<Type>(-999)) {
              valid_model = false;
              FIMS_ERROR_LOG(
                  "No recruitment process function defined for population " +
                  fims::to_string(p->id) +
                  ". FIMS requires recruitment process functions be defined "
                  "for all "
                  "recruitments when running a catch at age model.");
            }

            if (p->growth_id == static_cast<Type>(-999)) {
              valid_model = false;
              FIMS_ERROR_LOG(
                  "No growth function defined for population " +
                  fims::to_string(p->id) +
                  ". FIMS requires growth functions be defined for all "
                  "populations when running a catch at age model.");
            }

            if (p->maturity_id == static_cast<Type>(-999)) {
              valid_model = false;

              FIMS_WARNING_LOG(
                  "No maturity function defined for population " +
                  fims::to_string(p->id) +
                  ". FIMS requires maturity functions be defined for all "
                  "populations when running a catch at age model.");
            }
          }
        }
      }
    }
    return valid_model;
  }
};

template <typename Type>
std::shared_ptr<Information<Type>> Information<Type>::fims_information =
    nullptr;  // singleton instance

}  // namespace fims_info

#endif /* FIMS_COMMON_INFORMATION_HPP */

/**
 * @file model_object.hpp
 * @brief Definition of the FIMSObject structure.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */

#ifndef FIMS_COMMON_MODEL_OBJECT_HPP
#define FIMS_COMMON_MODEL_OBJECT_HPP

#include <stdint.h>

#include <vector>

#include "def.hpp"
#include "fims_vector.hpp"

namespace fims_model_object {

/**
 * @brief FIMSObject struct that defines member types and returns the unique id
 */
template <typename Type>
struct FIMSObject {
  uint32_t id; /**< unique identifier assigned for all fims objects */
  std::vector<Type*> parameters; /**< list of estimable parameters */
  std::vector<Type*>
      random_effects_parameters; /**< list of all random effects parameters */
  std::vector<Type*>
      fixed_effects_parameters; /**< list of fixed effects parameters */

  virtual ~FIMSObject() {}

  /**
   * @brief Getter that returns the unique id for parameters in the model
   */
  uint32_t GetId() const { return id; }

  /**
   * @brief Check the dimensions of an object
   *
   * @param actual The actual dimensions.
   * @param expected The expected dimensions.
   * @return true
   * @return false
   */
  inline bool CheckDimensions(size_t actual, size_t expected) {
    if (actual != expected) {
      return false;
    }

    return true;
  }
};

}  // namespace fims_model_object

#endif /* FIMS_COMMON_MODEL_OBJECT_HPP */

/**
 * @file model.hpp
 * @brief : Loops over model components and returns the negative log-likelihood
 * function.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_COMMON_MODEL_HPP
#define FIMS_COMMON_MODEL_HPP

#include <future>
#include <memory>

#include "information.hpp"

namespace fims_model {

/**
 * @brief Model class. FIMS objective function.
 */
template <typename Type>
class Model {  // may need singleton
 public:
  static std::shared_ptr<Model<Type>>
      fims_model; /**< Create a shared fims_model as a pointer to Model*/
  std::shared_ptr<fims_info::Information<Type>>
      fims_information; /**< Create a shared fims_information as a pointer to
                         Information*/

#ifdef TMB_MODEL
  bool do_tmb_reporting = true;
  ::objective_function<Type> *of;
#endif

  // constructor

  virtual ~Model() {}

  /**
   * Returns a single Information object for type Type.
   *
   * @return singleton for type Type
   */
  static std::shared_ptr<Model<Type>> GetInstance() {
    if (Model<Type>::fims_model == nullptr) {
      Model<Type>::fims_model = std::make_shared<fims_model::Model<Type>>();
      Model<Type>::fims_model->fims_information =
          fims_info::Information<Type>::GetInstance();
    }
    return Model<Type>::fims_model;
  }

  /**
   * @brief Evaluate. Calculates the joint negative log-likelihood function.
   */
  const Type Evaluate() {
    // jnll = negative-log-likelihood (the objective function)
    Type jnll = static_cast<Type>(0.0);
    typename fims_info::Information<Type>::model_map_iterator m_it;
    // Check if fims_information is set
    if (this->fims_information == nullptr) {
      FIMS_ERROR_LOG(
          "fims_information is not set. Please set fims_information before "
          "calling Evaluate().");
      return jnll;
    }

    // Create vector for reporting out nll components
    fims::Vector<Type> nll_vec(
        this->fims_information->density_components.size(), 0.0);

    for (m_it = this->fims_information->models_map.begin();
         m_it != this->fims_information->models_map.end(); ++m_it) {
      //(*m_it).second points to the Model module
      std::shared_ptr<fims_popdy::FisheryModelBase<Type>> m = (*m_it).second;
      m->of = this->of;  // link to TMB objective function
      m->Prepare();
      m->Evaluate();
    }

    // Loop over densities and evaluate joint negative log densities for priors
    typename fims_info::Information<Type>::density_components_iterator d_it;
    int nll_vec_idx = 0;
    size_t n_priors = 0;
    FIMS_INFO_LOG("Begin evaluating prior densities.")
    for (d_it = this->fims_information->density_components.begin();
         d_it != this->fims_information->density_components.end(); ++d_it) {
      std::shared_ptr<fims_distributions::DensityComponentBase<Type>> d =
          (*d_it).second;
#ifdef TMB_MODEL
      d->of = this->of;
#endif
      if (d->input_type == "prior") {
        nll_vec[nll_vec_idx] = -d->evaluate();
        jnll += nll_vec[nll_vec_idx];
        n_priors += 1;
        nll_vec_idx += 1;
      }
    }
    FIMS_INFO_LOG(
        "Model: Finished evaluating prior distributions. The jnll after "
        "evaluating " +
        fims::to_string(n_priors) + " priors is: " + fims::to_string(jnll));

    // Loop over densities and evaluate joint negative log-likelihoods for
    // random effects
    size_t n_random_effects = 0;
    for (d_it = this->fims_information->density_components.begin();
         d_it != this->fims_information->density_components.end(); ++d_it) {
      std::shared_ptr<fims_distributions::DensityComponentBase<Type>> d =
          (*d_it).second;
#ifdef TMB_MODEL
      d->of = this->of;
#endif
      if (d->input_type == "random_effects") {
        nll_vec[nll_vec_idx] = -d->evaluate();
        jnll += nll_vec[nll_vec_idx];
        n_random_effects += 1;
        nll_vec_idx += 1;
      }
    }
    FIMS_INFO_LOG(
        "Model: Finished evaluating random effect distributions. The jnll "
        "after evaluating priors and " +
        fims::to_string(n_random_effects) +
        " random_effects is: " + fims::to_string(jnll));

    // Loop over and evaluate data joint negative log-likelihoods
    int n_data = 0;
    for (d_it = this->fims_information->density_components.begin();
         d_it != this->fims_information->density_components.end(); ++d_it) {
      std::shared_ptr<fims_distributions::DensityComponentBase<Type>> d =
          (*d_it).second;
#ifdef TMB_MODEL
      d->of = this->of;
      // d->keep = this->keep;
#endif
      if (d->input_type == "data") {
        nll_vec[nll_vec_idx] = -d->evaluate();
        jnll += nll_vec[nll_vec_idx];
        n_data += 1;
        nll_vec_idx += 1;
      }
    }

// report out nll components
#ifdef TMB_MODEL
    vector<Type> nll_components = nll_vec.to_tmb();
    FIMS_REPORT_F(nll_components, this->of);
    FIMS_REPORT_F(jnll, this->of);
#endif

    // report out model family objects
    for (m_it = this->fims_information->models_map.begin();
         m_it != this->fims_information->models_map.end(); ++m_it) {
      //(*m_it).second points to the Model module
      std::shared_ptr<fims_popdy::FisheryModelBase<Type>> m = (*m_it).second;
      m->Report();
    }

    return jnll;
  }
};

// Create singleton instance of Model class
template <typename Type>
std::shared_ptr<Model<Type>> Model<Type>::fims_model =
    nullptr;  // singleton instance
}  // namespace fims_model

#endif /* FIMS_COMMON_MODEL_HPP */


/**
 * @file density_components_base.hpp
 * @brief Declares the DensityComponentBase class, which is the base class for
 * all distribution functors.
 * @details This header defines two core templates used by concrete
 * distribution functors (e.g., NormalLPDF, LogNormalLPDF, MultinomialLPMF):
 * DistributionElementObject, which stores and resolves observed/expected
 * inputs, and DensityComponentBase, which adds shared bookkeeping for
 * log-likelihood contributions and simulation/reporting behavior.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef DENSITY_COMPONENT_BASE_HPP
#define DENSITY_COMPONENT_BASE_HPP

#include "../../common/data_object.hpp"
#include "../../common/model_object.hpp"
#include "../../interface/interface.hpp"
#include "../../common/fims_vector.hpp"
#include "../../common/fims_math.hpp"

namespace fims_distributions {

/** @brief Base class for all module_name functors.
 *
 * @tparam Type The type of the module_name functor.
 *
 */
template <typename Type>
struct DensityComponentBase : public fims_model_object::FIMSObject<Type> {
  /**
   * @brief Classification of the input pathway for this distribution object.
   * Options used by accessor methods are, "prior", "random_effects", and
   *"data".
   */
  std::string input_type;

  /** @brief Observed data. */
  std::shared_ptr<fims_data_object::DataObject<Type>> data_observed_values;

  /** @brief Expected value vector for prior-based pathways. */
  fims::Vector<Type> expected_values;

  /** @brief Pointer to random effects vector. */
  fims::Vector<Type>* re = NULL;

  /** @brief Expected value vector for random-effects pathways. */
  fims::Vector<Type>* re_expected_values = NULL;

  /** @brief Expected value vector for data pathways. */
  fims::Vector<Type>* data_expected_values = NULL;

  /** @brief Vector of pointers where each entry points to a prior parameter. */
  std::vector<fims::Vector<Type>*> priors;

  /**
   * @brief Input value of distribution function for priors or random effects.
   */
  fims::Vector<Type> observed_values;

  /**
   * @brief The expected mean of the distribution; overrides expected values.
   */
  fims::Vector<Type> expected_mean;

  /**
   * @brief If "yes", `expected_mean` is used instead of `expected_values`. The
   * default is "no" leading to the use of `expected_values`.
   */
  std::string use_mean = fims::to_string("no");

  // std::shared_ptr<DistributionElementObject<Type>> expected;
  // // Expected value of distribution function.

  /**
   * @brief Retrieve one observed value based on `input_type`.
   * @param i Index into the active observed source, e.g., vector or pointer.
   * @return Reference to the selected observed value.
   * @throws std::runtime_error If input_type is "prior" and priors is empty.
   */
  inline Type& get_observed(size_t i) {
    if (this->input_type == "data") {
      return data_observed_values->at(i);
    }
    if (this->input_type == "random_effects") {
      return (*re)[i];
    }
    if (this->input_type == "prior") {
      if (priors.size() == 0) {
        throw std::runtime_error("No priors defined for this distribution.");
      } else if (priors.size() == 1) {
        return (*(priors[0]))[i];
      } else if (priors.size() > 1) {
        return (*(priors[i]))[0];
      }
    }
    return observed_values[i];
  }

  /**
   * @brief Retrieve one observed matrix-like value based on `input_type`.
   * @param i Row index.
   * @param j Column index.
   * @return Reference to the selected observed value.
   */
  inline Type& get_observed(size_t i, size_t j) {
    if (this->input_type == "data") {
      return data_observed_values->at(i, j);
    }
    return observed_values[i * (j - 1) + j];
  }

  /**
   * @brief Retrieve one expected value based on `input_type` and `use_mean`.
   * @param i Index into the active expected source, e.g., vector or pointer.
   * @return Reference to the selected expected value.
   * @details If `use_mean == "yes"`, `expected_mean` overrides other expected
   * vectors and is accessed via scalar/vector semantics.
   */
  inline Type& get_expected(size_t i) {
    if (this->input_type == "data") {
      return (*data_expected_values)[i];
    } else if (this->use_mean == "yes") {
      return this->expected_mean.get_force_scalar(i);
    } else if (this->input_type == "random_effects") {
      return (*re_expected_values)[i];
    } else {
      return this->expected_values.get_force_scalar(i);
    }
  }

  /**
   * @brief Get length of the active observed input vector.
   * @return Size of the observed input under the current `input_type`.
   */
  inline size_t get_n_x() {
    if (this->input_type == "data") {
      return this->data_observed_values->data.size();
    }
    if (this->input_type == "random_effects") {
      return (*re).size();
    }
    if (this->input_type == "prior") {
      return this->expected_values.size();
    }
    return observed_values.size();
  }

  /**
   * @brief Get length of the active expected input vector.
   * @return Size of the expected input under the current `input_type`.
   */
  inline size_t get_n_expected() {
    if (this->input_type == "data") {
      return (*data_expected_values).size();
    }
    if (this->input_type == "random_effects") {
      return (*re_expected_values).size();
    }
    if (this->input_type == "prior") {
      return this->expected_values.size();
    }
    return observed_values.size();
  }
  // id_g is the ID of the instance of the DensityComponentBase class.
  // this is like a memory tracker.
  // Assigning each one its own ID is a way to keep track of
  // all the instances of the DensityComponentBase class.
  /**
   * @brief Global unique identifier for distribution modules.
   */
  static uint32_t id_g;

  /**
   * @brief Total log probability density contribution of the distribution.
   *
   */
  Type lpdf;

  /**
   * @brief ID of observed data component.
   */
  int observed_data_id_m = -999;

  /**
   * @brief Vector storing observation-level log-likelihood contributions.
   */
  fims::Vector<Type> lpdf_vec;

  /**
   * @brief Boolean; if true, one-step-ahead (OSA) residuals are calculated.
   */
  bool osa_flag = false;

  /**
   * @brief Boolean; if true, data are simulated from the distribution.
   */
  bool simulate_flag = false;

  /**
   * @brief Unique ID for variable map that points to a fims::Vector.
   */
  std::vector<uint32_t> key;

#ifdef TMB_MODEL
  /**
   * @brief Pointer to the TMB objective function.
   */
  ::objective_function<Type>* of;
#endif

  /**
   * @brief Constructor, which initializes default prior pointer state and ID.
   */
  DensityComponentBase() {
    // initialize the priors vector with a size of 1 and set the first element
    // to NULL
    this->priors.resize(1);
    this->priors[0] = NULL;
    this->id = DensityComponentBase::id_g++;
  }

  virtual ~DensityComponentBase() {}
  /**
   * @brief Evaluate the distribution-specific log-likelihood contribution.
   * @return Total log-likelihood contribution for the active inputs.
   */
  virtual const Type evaluate() = 0;
};

/** @brief Default id of the singleton distribution class
 */
template <typename Type>
uint32_t DensityComponentBase<Type>::id_g = 0;

}  // namespace fims_distributions

#endif /* DENSITY_COMPONENT_BASE_HPP */

/**
 * @file lognormal_lpdf.hpp
 * @brief Implements the LogNormalLPDF distribution functor used by FIMS to
 * evaluate observation-level and total log-likelihood contributions under a
 * lognormal error model for data, priors, and random effects.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef LOGNORMAL_LPDF
#define LOGNORMAL_LPDF

#include "density_components_base.hpp"
#include "../../common/fims_vector.hpp"
#include "../../common/def.hpp"

namespace fims_distributions {
/**
 * @copybrief lognormal_lpdf.hpp
 *
 * @details This implementation relies on [TMB's R-style `dnorm()` utility](
 * https://kaskr.github.io/adcomp/group__R__style__distribution.html) for
 * normal log-density calculations on log-transformed values. Specifically,
 * when evaluating the lognormal likelihood, observations are transformed with
 * `log(x)` and passed to `dnorm(..., give_log = true)` to obtain log-density
 * values. For data inputs, the Jacobian adjustment `-log(x)` is applied where
 * appropriate to convert from normal density on the log scale to the lognormal
 * density on the original scale.
 *
 * For `data` input, values equal to `na_value` are skipped and contribute zero
 * to the objective. Per-observation contributions are stored in `lpdf_vec`;
 * the summed total is returned by `evaluate()` and stored in `lpdf`.
 */
template <typename Type>
struct LogNormalLPDF : public DensityComponentBase<Type> {
  /**
   * @brief Natural log of the standard deviation of the distribution on the
   * log scale. The argument can be a vector or scalar, where the latter is
   * referenced for each instance through the use of
   * \ref fims::Vector::get_force_scalar(size_t) "get_force_scalar()".
   */
  fims::Vector<Type> log_sd;

  /** @brief Constructor.
   */
  LogNormalLPDF() : DensityComponentBase<Type>() {}

  /** @brief Destructor.
   */
  virtual ~LogNormalLPDF() {}

  /**
   * @brief Evaluates the lognormal log probability density function.
   * @details The following equation is the lognormal probability density
   * function, and thus, the log of it is evaluated:
   * \f[
   * f(x) = \frac{1.0}{ x\sigma\sqrt{2\pi}
   * }\mathrm{exp}\Bigg(-\frac{(\mathrm{ln}(x) - \mu)^{2}}{2\sigma^{2}}\Bigg),
   * \f]
   * where \f$\mu\f$ is the mean of the distribution of \f$\mathrm{ln(x)}\f$
   * and \f$\sigma^2\f$ is the variance of \f$\mathrm{ln}(x)\f$.
   */
  virtual const Type evaluate() {
    // set vector size based on input type (prior, process, or data)
    size_t n_x = this->get_n_x();
    // get expected value vector size
    size_t n_expected = this->get_n_expected();
    // setup vector for recording the log probability density function values
    this->lpdf_vec.resize(n_x);
    std::fill(this->lpdf_vec.begin(), this->lpdf_vec.end(),
              static_cast<Type>(0));
    this->lpdf = static_cast<Type>(0);

    // Dimension checks
    // TODO: fix dimension check as expected values no longer used for data
    if (n_x != n_expected) {
      if (n_expected == 1) {
        n_expected = n_x;
      } else if (n_x > n_expected) {
        n_x = n_expected;
      }
    }

    if (this->log_sd.size() > 1 && n_x != this->log_sd.size()) {
      throw std::invalid_argument(
          "LognormalLPDF::Vector index out of bounds. The size of observed "
          "data does not equal the size of the log_sd vector. The observed "
          "data vector is of size " +
          fims::to_string(n_x) + " and the log_sd vector is of size " +
          fims::to_string(this->log_sd.size()));
    }

    for (size_t i = 0; i < n_x; i++) {
#ifdef TMB_MODEL
      if (this->input_type == "data") {
        // if data, check if there are any NA values and skip lpdf calculation
        // if there are See Deroba and Miller, 2016
        // (https://doi.org/10.1016/j.fishres.2015.12.002) for the use of
        // lognormal constant
        if (this->get_observed(i) != this->data_observed_values->na_value) {
          this->lpdf_vec[i] =
              dnorm(log(this->get_observed(i)), this->get_expected(i),
                    fims_math::exp(log_sd.get_force_scalar(i)), true) -
              log(this->get_observed(i));
        } else {
          this->lpdf_vec[i] = 0;
        }
      } else {
        if (this->input_type == "random_effects") {
          // if random effects, no lognormal constant needs to be applied
          this->lpdf_vec[i] =
              dnorm(log(this->get_observed(i)), this->get_expected(i),
                    fims_math::exp(log_sd.get_force_scalar(i)), true);
        } else {
          this->lpdf_vec[i] =
              dnorm(log(this->get_observed(i)), this->get_expected(i),
                    fims_math::exp(log_sd.get_force_scalar(i)), true) -
              log(this->get_observed(i));
        }
      }

      this->lpdf += this->lpdf_vec[i];
      if (this->simulate_flag) {
        FIMS_SIMULATE_F(this->of) {  // preprocessor definition in interface.hpp
                                     // this simulates data that is mean biased
          if (this->input_type == "data") {
            this->data_observed_values->at(i) = fims_math::exp(
                rnorm(this->get_expected(i),
                      fims_math::exp(log_sd.get_force_scalar(i))));
          }
          if (this->input_type == "random_effects") {
            (*this->re)[i] = fims_math::exp(
                rnorm(this->get_expected(i),
                      fims_math::exp(log_sd.get_force_scalar(i))));
          }
          if (this->input_type == "prior") {
            (*(this->priors[i]))[0] = fims_math::exp(
                rnorm(this->get_expected(i),
                      fims_math::exp(log_sd.get_force_scalar(i))));
          }
        }
      }
#endif
    }
#ifdef TMB_MODEL
    vector<Type> lognormal_observed_values = this->observed_values.to_tmb();
    //  FIMS_REPORT_F(lognormal_observed_values, this->of);
#endif
    return (this->lpdf);
  }
};
}  // namespace fims_distributions
#endif

/**
 * @file multinomial_lpmf.hpp
 * @brief Implements the MultinomialLPMF distribution functor used by FIMS to
 * evaluate the observation-level and total log-likelihood contributions under
 * a multinomial error model for data, priors, and random effects.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef MULTINOMIAL_LPMF
#define MULTINOMIAL_LPMF

#include "density_components_base.hpp"
#include "../../common/fims_vector.hpp"
#include "../../common/def.hpp"

namespace fims_distributions {
/**
 * @copybrief multinomial_lpmf.hpp
 *
 * @details This implementation relies on [TMB's R-style `dmultinom()`
 * utility]( https://kaskr.github.io/adcomp/group__R__style__distribution.html)
 * to compute row-wise multinomial log-probability mass contributions from
 * observed counts (`x_vector`) and expected proportions (`prob_vector`).
 * Specifically, when evaluating the multinomial likelihood, observations are
 * passed to `dmultinom(..., give_log = true)`.
 *
 * For `data` input, if any element in a row is equal to `na_value`, the entire
 * row is skipped and contributes zero to the objective. Contributions are
 * stored in `lpdf_vec`. The summed total is returned by `evaluate()` and
 * stored in `lpdf`.
 *
 * Row observations could be counts of each age for a given time step, where
 * additional time steps would be additional rows. Thus, columns are bins.
 */
template <typename Type>
struct MultinomialLPMF : public DensityComponentBase<Type> {
  /**
   * @brief Dimensions of the number of rows and columns of the multivariate
   * dataset.
   */
  fims::Vector<size_t> dims;

  /** @brief Constructor.
   */
  MultinomialLPMF() : DensityComponentBase<Type>() {}

  /** @brief Destructor.
   */
  virtual ~MultinomialLPMF() {}

  /**
   * @brief Evaluates the multinomial log probability mass function.
   * @details The following equation is the multinomial probability mass
   * function, and thus, the log of it is evaluated:
   * \f[
   * f(\underline{y}) = \frac{n!}{y_{1}!...
   * y_{k}!}p^{y_{1}}_{1}...p^{y_{k}}_{k}, \f] where \f$k\f$ is the number of
   * categories, \f$n\f$ is the sample size, \f$\mu_{i}\f$ is the mean of
   * \f$y_{i}\f$ and is equal to \f$np_{i}\f$, and \f$\sigma^{2}_{i}\f$ is the
   * variance of \f$y_{i}\f$ and is equal to \f$np_{i}(1-p_{i})\f$.
   */
  virtual const Type evaluate() {
    // set dims using data_observed_values if no user input
    if (dims.size() != 2) {
      dims.resize(2);
      dims[0] = this->data_observed_values->get_imax();
      dims[1] = this->data_observed_values->get_jmax();
    }

    // setup vector for recording the log probability density function values
    this->lpdf = static_cast<Type>(0.0); /**< total log probability mass
                                           contribution of the distribution */
    this->lpdf_vec.resize(dims[0] * dims[1]);
    std::fill(this->lpdf_vec.begin(), this->lpdf_vec.end(), 0);
    size_t lpdf_vec_idx = 0; /**< index for lpdf_vec vector */
    // Dimension checks
    if (this->input_type == "data") {
      if (this->data_expected_values) {
        if (dims[0] * dims[1] != this->data_expected_values->size()) {
          throw std::invalid_argument(
              "MultinomialLPDF: Vector index out of bounds. The dimension of "
              "the "
              "number of rows times the number of columns is of size " +
              fims::to_string(dims[0] * dims[1]) +
              " and the expected vector is of size " +
              fims::to_string(this->data_expected_values->size()));
        }
      }
    } else {
      if (dims[0] * dims[1] != this->observed_values.size()) {
        throw std::invalid_argument(
            "MultinomialLPDF: Vector index out of bounds. The dimension of the "
            "number of  rows times the number of columns is of size " +
            fims::to_string(dims[0] * dims[1]) +
            " and the observed vector is of size " +
            fims::to_string(this->observed_values.size()));
      }
      if (this->observed_values.size() != this->expected_values.size()) {
        throw std::invalid_argument(
            "MultinomialLPDF: Vector index out of bounds. The dimension of the "
            "observed vector of size " +
            fims::to_string(this->observed_values.size()) +
            " and the expected vector is of size " +
            fims::to_string(this->expected_values.size()));
      }
    }

    for (size_t i = 0; i < dims[0]; i++) {
      // for each row, create new observed_values and prob vectors
      fims::Vector<Type> observed_values_vector;
      fims::Vector<Type> prob_vector;
      observed_values_vector.resize(dims[1]);
      prob_vector.resize(dims[1]);

      // Skips the entire row if any values are NA
      bool containsNA = false;

#ifdef TMB_MODEL
      for (size_t j = 0; j < dims[1]; j++) {
        if (this->input_type == "data") {
          // if data, check if there are any NA values and skip lpdf calculation
          // for entire row if there are
          if (this->get_observed(static_cast<size_t>(i),
                                 static_cast<size_t>(j)) ==
              this->data_observed_values->na_value) {
            containsNA = true;
            break;
          }
          if (!containsNA) {
            size_t idx = (i * dims[1]) + j;
            observed_values_vector[j] = this->get_observed(i, j);
            prob_vector[j] = this->get_expected(idx);
          }
        } else {
          // if not data (i.e. prior or process), use observed_values vector
          // instead of data_observed_values
          size_t idx = (i * dims[1]) + j;
          observed_values_vector[j] = this->get_observed(idx);
          prob_vector[j] = this->get_expected(idx);
        }
      }

      if (!containsNA) {
        std::fill(this->lpdf_vec.begin() + lpdf_vec_idx,
                  this->lpdf_vec.begin() + lpdf_vec_idx + dims[1],
                  dmultinom(observed_values_vector.to_tmb(),
                            prob_vector.to_tmb(), true));

        this->lpdf += this->lpdf_vec[lpdf_vec_idx];
      } else {
        this->lpdf_vec[i] = 0;
      }
      lpdf_vec_idx += dims[1];
/*
if (this->simulate_flag)
{
    FIMS_SIMULATE_F(this->of)
    {
        fims::Vector<Type> sim_observed;
        sim_observed.resize(dims[1]);
        sim_observed = rmultinom(prob_vector);
        sim_observed.resize(this->observed_values.size());
        for (size_t j = 0; j < dims[1]; j++)
        {
            idx = (i * dims[1]) + j;
            this->observed_values[idx] = sim_observed[j];
        }
    }
}
*/
#endif
    }

#ifdef TMB_MODEL
#endif
    return (this->lpdf);
  }
};
}  // namespace fims_distributions
#endif

/**
 * @file normal_lpdf.hpp
 * @brief Implements the NormalLPDF distribution functor used by FIMS to
 * evaluate observation-level and total log-likelihood contributions under a
 * normal error model for data, priors, and random effects.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */

#ifndef NORMAL_LPDF
#define NORMAL_LPDF

#include "density_components_base.hpp"
#include "../../common/fims_vector.hpp"
#include "../../common/def.hpp"

namespace fims_distributions {
/**
 * @copybrief normal_lpdf.hpp
 *
 * @details This implementation relies on [TMB's R-style `dnorm()` utility](
 * https://kaskr.github.io/adcomp/group__R__style__distribution.html) for
 * normal log-density calculations. Specifically, when evaluating the normal
 * likelihood, observations are passed to `dnorm(..., give_log = true)` to
 * obtain log-density values.
 *
 * For `data` input, values equal to `na_value` are skipped and contribute zero
 * to the objective. Per-observation contributions are stored in `lpdf_vec`;
 * the summed total is returned by `evaluate()` and stored in `lpdf`.
 */
template <typename Type>
struct NormalLPDF : public DensityComponentBase<Type> {
  /**
   * @brief The natural log of the standard deviation of the distribution. The
   * argument can be a vector or scalar, where the latter is referenced for
   * each instance through the use of
   * \ref fims::Vector::get_force_scalar(size_t) "get_force_scalar()".
   */
  fims::Vector<Type> log_sd;

  /** @brief Constructor.
   */
  NormalLPDF() : DensityComponentBase<Type>() {}

  /** @brief Destructor.
   */
  virtual ~NormalLPDF() {}

  /**
   * @brief Evaluates the normal log probability density function.
   * @details The following equation is normal probability density function,
   * and thus, the log of it evaluated:
   * \f[
   * f(x) =
   * \frac{1}{\sigma\sqrt{2\pi}}\mathrm{exp}\Bigg(-\frac{(x-\mu)^2}{2\sigma^2}
   * \Bigg), \f] where \f$\mu\f$ is the mean of the distribution and
   * \f$\sigma^2\f$ is the variance.
   */
  virtual const Type evaluate() {
    // set vector size based on input type (prior, process, or data)
    size_t n_x = this->get_n_x();
    // get expected value vector size
    size_t n_expected = this->get_n_expected();
    // setup vector for recording the log probability density function values
    this->lpdf_vec.resize(n_x);
    std::fill(this->lpdf_vec.begin(), this->lpdf_vec.end(),
              static_cast<Type>(0));
    this->lpdf = static_cast<Type>(0);

    // Dimension checks
    if (n_x != n_expected) {
      if (n_expected == 1) {
        n_expected = n_x;
      } else if (n_x > n_expected) {
        n_x = n_expected;
      }
    }

    if (this->log_sd.size() > 1 && n_x != this->log_sd.size()) {
      throw std::invalid_argument(
          "NormalLPDF::Vector index out of bounds. The size of observed data "
          "does not equal the size of the log_sd vector. The observed data "
          "vector is of size " +
          fims::to_string(n_x) + " and the log_sd vector is of size " +
          fims::to_string(this->log_sd.size()));
    }

    for (size_t i = 0; i < n_x; i++) {
#ifdef TMB_MODEL
      if (this->input_type == "data") {
        // if data, check if there are any NA values and skip lpdf calculation
        // if there are
        if (this->get_observed(i) != this->data_observed_values->na_value) {
          this->lpdf_vec[i] =
              dnorm(this->get_observed(i), this->get_expected(i),
                    fims_math::exp(log_sd.get_force_scalar(i)), true);
        } else {
          this->lpdf_vec[i] = 0;
        }
        // if not data (i.e. prior or process), use x vector instead of
        // observed_values
      } else {
        this->lpdf_vec[i] =
            dnorm(this->get_observed(i), this->get_expected(i),
                  fims_math::exp(log_sd.get_force_scalar(i)), true);
      }
      this->lpdf += this->lpdf_vec[i];
      if (this->simulate_flag) {
        FIMS_SIMULATE_F(this->of) {
          if (this->input_type == "data") {
            this->data_observed_values->at(i) =
                rnorm(this->get_expected(i),
                      fims_math::exp(log_sd.get_force_scalar(i)));
          }
          if (this->input_type == "random_effects") {
            (*this->re)[i] = rnorm(this->get_expected(i),
                                   fims_math::exp(log_sd.get_force_scalar(i)));
          }
          if (this->input_type == "prior") {
            (*(this->priors[i]))[0] =
                rnorm(this->get_expected(i),
                      fims_math::exp(log_sd.get_force_scalar(i)));
          }
        }
      }
#endif
      /* osa not working yet
        if(osa_flag){//data observation type implements osa residuals
            //code for osa cdf method
            this->lpdf_vec[i] = this->keep.cdf_lower[i] * log(
        pnorm(this->observed_values[i], this->get_expected(i), sd[i]) );
        this->lpdf_vec[i] = this->keep.cdf_upper[i] * log( 1.0 -
        pnorm(this->observed_values[i], this->get_expected(i), sd[i]) );
        } */
    }
#ifdef TMB_MODEL
    vector<Type> normal_observed_values = this->observed_values.to_tmb();
#endif
    return (this->lpdf);
  }
};

}  // namespace fims_distributions
#endif

/**
 * @file interface.hpp
 * @brief An interface to the modeling platforms, e.g., TMB.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */

#ifndef FIMS_INTERFACE_HPP
#define FIMS_INTERFACE_HPP

/*
 * @brief Interface file. Uses pre-processing macros
 * to interface with multiple modeling platforms.
 */

// traits for interfacing with TMB

#ifdef TMB_MODEL
// use isnan macro in math.h instead of TMB's isnan for fixing the r-cmd-check
// issue
#include <math.h>

#include <TMB.hpp>

// define REPORT, ADREPORT, and SIMULATE
#define FIMS_REPORT_F(name, F)                                         \
  if (isDouble<Type>::value &&                                         \
      F->current_parallel_region < static_cast<Type>(0)) {             \
    Rf_defineVar(Rf_install(#name), PROTECT(asSEXP(name)), F->report); \
    UNPROTECT(1);                                                      \
  }

#define FIMS_REPORT_F_(name, obj, F)                                 \
  if (isDouble<Type>::value &&                                       \
      F->current_parallel_region < static_cast<Type>(0)) {           \
    Rf_defineVar(Rf_install(name), PROTECT(asSEXP(obj)), F->report); \
    UNPROTECT(1);                                                    \
  }

#define ADREPORT_F(name, F) F->reportvector.push(name, #name);

template <typename Type>
vector<Type> ADREPORTvector(vector<vector<Type> > x) {
  int outer_dim = x.size();
  int dim = 0;
  for (int i = 0; i < outer_dim; i++) {
    dim += x(i).size();
  }
  vector<Type> res(dim);
  int idx = 0;
  for (int i = 0; i < outer_dim; i++) {
    int inner_dim = x(i).size();
    for (int j = 0; j < inner_dim; j++) {
      res(idx) = x(i)(j);
      idx += 1;
    }
  }
  return res;
}

#define FIMS_SIMULATE_F(F) if (isDouble<Type>::value && F->do_simulate)

#endif /* TMB_MODEL */

#ifndef TMB_MODEL
/**
 * @brief TMB macro that simulates data.
 */
#define FIMS_SIMULATE_F(F)
/**
 * @brief TMB macro that reports variables.
 */
#define FIMS_REPORT_F(name, F)
/**
 * @brief TMB macro that reports variables and uncertainties.
 */
#define ADREPORT_F(name, F)
#endif

#endif /* FIMS_INTERFACE_HPP */

/**
 * @file rcpp_interface.hpp
 * @brief The Rcpp interface to declare things.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_INTERFACE_RCPP_INTERFACE_HPP
#define FIMS_INTERFACE_RCPP_INTERFACE_HPP
#include "../../common/model.hpp"
#include "../../utilities/fims_json.hpp"
#include "rcpp_objects/rcpp_data.hpp"
#include "rcpp_objects/rcpp_distribution.hpp"
#include "rcpp_objects/rcpp_fleet.hpp"
#include "rcpp_objects/rcpp_growth.hpp"
#include "rcpp_objects/rcpp_interface_base.hpp"
#include "rcpp_objects/rcpp_maturity.hpp"
#include "rcpp_objects/rcpp_models.hpp"
#include "rcpp_objects/rcpp_natural_mortality.hpp"
#include "rcpp_objects/rcpp_population.hpp"
#include "rcpp_objects/rcpp_recruitment.hpp"
#include "rcpp_objects/rcpp_selectivity.hpp"

/**
 * Initializes the logging system, setting all signal handling.
 */
void init_logging() {
  std::signal(SIGSEGV, &fims::WriteAtExit);
  std::signal(SIGINT, &fims::WriteAtExit);
  std::signal(SIGABRT, &fims::WriteAtExit);
  std::signal(SIGFPE, &fims::WriteAtExit);
  std::signal(SIGILL, &fims::WriteAtExit);
  std::signal(SIGTERM, &fims::WriteAtExit);
}

/**
 * @brief Initialize and construct the FIMS model using TMB.
 *
 * @details
 * This function sets up the core C++ objects required for building the
 * objective function with TMB before optimizing a FIMS model. The main steps
 * of the function are as follows:
 * - The logging system is initialized and any existing model structures are
 *   cleared, ensuring a clean slate for a new model.
 * - It resets and prepares the main model information objects
 *   (fims_info::Information singletons), ensuring all internal data and
 *   settings are cleared and ready for a new model run. This step is essential
 *   for both initializing the model structure and avoiding conflicts from
 *   previous runs.
 * - It iterates over all registered FIMS interface objects and adds them to
 *   the TMB model context.
 * - After all of the objects are registered, it calls
 *   fims_info::Information::CreateModel() and
 *   fims_info::Information::CheckModel() on the base fims_info::Information
 *   object.
 * - It instantiates the singleton fims_model::Model object which represents
 *   the constructed TMB model.
 *
 * Typically the average user does not interact with this function because it
 * is called within <a href =
 * "https://noaa-fims.github.io/FIMS/reference/initialize_fims.html">`initialize_fims`</a>.
 *
 * @see init_logging()
 * @see fims_info::Information::Clear()
 * @see fims_info::Information::CreateModel()
 * @see fims_info::Information::CheckModel()
 * @see fims_info::Information::GetInstance()
 * @see <a href =
 * "https://noaa-fims.github.io/FIMS/reference/initialize_fims.html"
 * target="_blank">`initialize_fims()`</a>
 * @return A boolean is returned, where true indicates that the model was
 * successfully created.
 */
bool CreateTMBModel() {
  init_logging();

  // clear first
  //  base model
  std::shared_ptr<fims_info::Information<TMB_FIMS_REAL_TYPE>> info0 =
      fims_info::Information<TMB_FIMS_REAL_TYPE>::GetInstance();
  info0->Clear();

  std::shared_ptr<fims_info::Information<TMBAD_FIMS_TYPE>> info =
      fims_info::Information<TMBAD_FIMS_TYPE>::GetInstance();
  info->Clear();

  FIMS_INFO_LOG(
      "Adding FIMS objects to TMB, " +
      fims::to_string(FIMSRcppInterfaceBase::fims_interface_objects.size()) +
      " objects");
  for (size_t i = 0; i < FIMSRcppInterfaceBase::fims_interface_objects.size();
       i++) {
    FIMSRcppInterfaceBase::fims_interface_objects[i]->add_to_fims_tmb();
  }

  // base model
  info0->CreateModel();
  info0->CheckModel();

  info->CreateModel();

  // instantiate the model? TODO: Ask Matthew what this does
  std::shared_ptr<fims_model::Model<TMB_FIMS_REAL_TYPE>> m0 =
      fims_model::Model<TMB_FIMS_REAL_TYPE>::GetInstance();

  return true;
}

/* Dictionary block for shared documentation.
  [details_set_x_parameters]
  Updates the internal parameter values for the model base of type
  TMB_FIMS_REAL_TYPE. It is typically called before finalize() or
  @ref CatchAtAgeInterface::to_json "`get_output()`" to ensure the correct
  values are used because TMB doesn't always keep the updated parameters in
  the "double" version of the tape. So we need to update those first.
  \n\n
  Usage example in R:
  \code{.R}
  set_fixed_parameters(c(1, 2, 3))
  set_random_parameters(c(1, 2, 3))
  catch_at_age$get_output()
  \endcode
  [details_set_x_parameters]
*/
/* Dictionary block for shared documentation.
  [param_par]
  @param par A vector of parameter values.
  [param_par]
 */

/**
 * @brief Update fixed parameters in the tape, so the output is correct.
 * @details @snippet{doc} this details_set_x_parameters
 * @snippet{doc} this param_par
 * @see set_random_parameters()
 */
void set_fixed_parameters(Rcpp::NumericVector par) {
  // base model
  std::shared_ptr<fims_info::Information<TMB_FIMS_REAL_TYPE>> info0 =
      fims_info::Information<TMB_FIMS_REAL_TYPE>::GetInstance();

  for (size_t i = 0; i < info0->fixed_effects_parameters.size(); i++) {
    *info0->fixed_effects_parameters[i] = par[i];
  }
}

/**
 * @brief Gets the fixed parameters vector object.
 *
 * @return Rcpp::NumericVector
 */
Rcpp::NumericVector get_fixed_parameters_vector() {
  // base model
  std::shared_ptr<fims_info::Information<TMB_FIMS_REAL_TYPE>> info0 =
      fims_info::Information<TMB_FIMS_REAL_TYPE>::GetInstance();

  Rcpp::NumericVector p;

  for (size_t i = 0; i < info0->fixed_effects_parameters.size(); i++) {
    p.push_back(*info0->fixed_effects_parameters[i]);
  }

  return p;
}

/**
 * @brief Update random effect parameters in the tape, so the output is correct.
 * @details @snippet{doc} this details_set_x_parameters
 * @snippet{doc} this param_par
 * @see set_fixed_parameters()
 */
void set_random_parameters(Rcpp::NumericVector par) {
  // base model
  std::shared_ptr<fims_info::Information<TMB_FIMS_REAL_TYPE>> info0 =
      fims_info::Information<TMB_FIMS_REAL_TYPE>::GetInstance();

  for (size_t i = 0; i < info0->random_effects_parameters.size(); i++) {
    *info0->random_effects_parameters[i] = par[i];
  }
}

/**
 * @brief Gets the random parameters vector object.
 *
 * @return Rcpp::NumericVector
 */
Rcpp::NumericVector get_random_parameters_vector() {
  // base model
  std::shared_ptr<fims_info::Information<TMB_FIMS_REAL_TYPE>> d0 =
      fims_info::Information<TMB_FIMS_REAL_TYPE>::GetInstance();

  Rcpp::NumericVector p;

  for (size_t i = 0; i < d0->random_effects_parameters.size(); i++) {
    p.push_back(*d0->random_effects_parameters[i]);
  }

  return p;
}

/**
 * @brief Gets the parameter names object.
 *
 * @param pars
 * @return Rcpp::List
 */
Rcpp::List get_parameter_names(Rcpp::List pars) {
  // base model
  std::shared_ptr<fims_info::Information<TMB_FIMS_REAL_TYPE>> d0 =
      fims_info::Information<TMB_FIMS_REAL_TYPE>::GetInstance();

  pars.attr("names") = d0->parameter_names;

  return pars;
}

/**
 * @brief Gets the random effects names object.
 *
 * @param pars
 * @return Rcpp::List
 */
Rcpp::List get_random_names(Rcpp::List pars) {
  // base model
  std::shared_ptr<fims_info::Information<TMB_FIMS_REAL_TYPE>> d0 =
      fims_info::Information<TMB_FIMS_REAL_TYPE>::GetInstance();

  pars.attr("names") = d0->random_effects_names;

  return pars;
}

/**
 * @brief Clears the internal objects.
 *
 * @tparam Type
 */
template <typename Type>
void clear_internal() {
  std::shared_ptr<fims_info::Information<Type>> d0 =
      fims_info::Information<Type>::GetInstance();
  d0->Clear();
}

/**
 * @brief Clears the vector of independent variables.
 */
void clear() {
  FIMS_INFO_LOG("Clearing FIMS objects from interface stack");
  // rcpp_interface_base.hpp
  FIMSRcppInterfaceBase::fims_interface_objects.clear();

  // Parameter and ParameterVector
  Parameter::id_g = 1;
  ParameterVector::id_g = 1;
  // rcpp_data.hpp
  DataInterfaceBase::id_g = 1;
  DataInterfaceBase::live_objects.clear();

  AgeCompDataInterface::id_g = 1;
  AgeCompDataInterface::live_objects.clear();

  LengthCompDataInterface::id_g = 1;
  LengthCompDataInterface::live_objects.clear();

  LandingsDataInterface::id_g = 1;
  LandingsDataInterface::live_objects.clear();

  IndexDataInterface::id_g = 1;
  IndexDataInterface::live_objects.clear();

  // rcpp_fleets.hpp
  FleetInterfaceBase::id_g = 1;
  FleetInterfaceBase::live_objects.clear();

  FleetInterface::id_g = 1;
  FleetInterface::live_objects.clear();

  // rcpp_growth.hpp
  GrowthInterfaceBase::id_g = 1;
  GrowthInterfaceBase::live_objects.clear();

  EWAAGrowthInterface::id_g = 1;
  EWAAGrowthInterface::live_objects.clear();

  // rcpp_maturity.hpp
  MaturityInterfaceBase::id_g = 1;
  MaturityInterfaceBase::live_objects.clear();

  LogisticMaturityInterface::id_g = 1;
  LogisticMaturityInterface::live_objects.clear();

  // rcpp_population.hpp
  PopulationInterfaceBase::id_g = 1;
  PopulationInterfaceBase::live_objects.clear();

  PopulationInterface::id_g = 1;
  PopulationInterface::live_objects.clear();

  // rcpp_recruitment.hpp
  RecruitmentInterfaceBase::id_g = 1;
  RecruitmentInterfaceBase::live_objects.clear();

  BevertonHoltRecruitmentInterface::id_g = 1;
  BevertonHoltRecruitmentInterface::live_objects.clear();

  // rcpp_selectivity.hpp
  SelectivityInterfaceBase::id_g = 1;
  SelectivityInterfaceBase::live_objects.clear();

  LogisticSelectivityInterface::id_g = 1;
  LogisticSelectivityInterface::live_objects.clear();

  DoubleLogisticSelectivityInterface::id_g = 1;
  DoubleLogisticSelectivityInterface::live_objects.clear();

  // rcpp_distribution.hpp
  DistributionsInterfaceBase::id_g = 1;
  DistributionsInterfaceBase::live_objects.clear();

  DnormDistributionsInterface::id_g = 1;
  DnormDistributionsInterface::live_objects.clear();

  DlnormDistributionsInterface::id_g = 1;
  DlnormDistributionsInterface::live_objects.clear();

  DmultinomDistributionsInterface::id_g = 1;
  DmultinomDistributionsInterface::live_objects.clear();

  FisheryModelInterfaceBase::id_g = 1;
  FisheryModelInterfaceBase::live_objects.clear();

  clear_internal<TMB_FIMS_REAL_TYPE>();
  clear_internal<TMBAD_FIMS_TYPE>();

  fims::FIMSLog::fims_log->clear();
}

/**
 * @brief Gets the log entries as a string in JSON format.
 */
std::string get_log() { return fims::FIMSLog::fims_log->get_log(); }

/**
 * @brief Gets the error entries from the log as a string in JSON format.
 */
std::string get_log_errors() { return fims::FIMSLog::fims_log->get_errors(); }

/**
 * @brief Gets the warning entries from the log as a string in JSON format.
 */
std::string get_log_warnings() {
  return fims::FIMSLog::fims_log->get_warnings();
}

/**
 * @brief Gets the info entries from the log as a string in JSON format.
 */
std::string get_log_info() { return fims::FIMSLog::fims_log->get_info(); }

/**
 * @brief If true, writes the log on exit.
 */
void write_log(bool write) {
  FIMS_INFO_LOG("Setting FIMS write log: " + fims::to_string(write));
  fims::FIMSLog::fims_log->write_on_exit = write;
}

/**
 * @brief Sets the path for the log file to be written to.
 */
void set_log_path(const std::string &path) {
  FIMS_INFO_LOG("Setting FIMS log path: " + path);
  fims::FIMSLog::fims_log->set_path(path);
}

/**
 * @brief If true, throws a runtime exception when an error is logged.
 */
void set_log_throw_on_error(bool throw_on_error) {
  fims::FIMSLog::fims_log->throw_on_error = throw_on_error;
}

/**
 * @brief Adds an info entry to the log from the R environment.
 */
void log_info(std::string log_entry) {
  fims::FIMSLog::fims_log->info_message(log_entry, -1, "R_env",
                                        "R_script_entry");
}

/**
 * @brief Adds a warning entry to the log from the R environment.
 */
void log_warning(std::string log_entry) {
  fims::FIMSLog::fims_log->warning_message(log_entry, -1, "R_env",
                                           "R_script_entry");
}

/**
 * @brief Escapes quotations.
 *
 * @param input A string.
 * @return std::string
 */
std::string escapeQuotes(const std::string &input) {
  std::string result = input;
  std::string search = "\"";
  std::string replace = "\\\"";

  // Find each occurrence of `"` and replace it with `\"`
  size_t pos = result.find(search);
  while (pos != std::string::npos) {
    result.replace(pos, search.size(), replace);
    pos = result.find(search,
                      pos + replace.size());  // Move past the replaced position
  }
  return result;
}

/**
 * @brief Adds a error entry to the log from the R environment.
 */
void log_error(std::string log_entry) {
  std::stringstream ss;
  ss << "capture.output(traceback(4))";
  SEXP expression, result;
  ParseStatus status;

  PROTECT(expression = R_ParseVector(Rf_mkString(ss.str().c_str()), 1, &status,
                                     R_NilValue));
  if (status != PARSE_OK) {
    Rcpp::Rcout << "Error parsing expression" << std::endl;
    UNPROTECT(1);
  }
  Rcpp::Rcout << "before call.";
  PROTECT(result = Rf_eval(VECTOR_ELT(expression, 0), R_GlobalEnv));
  Rcpp::Rcout << "after call.";
  UNPROTECT(2);
  std::stringstream ss_ret;
  ss_ret << "traceback: ";
  for (int j = 0; j < LENGTH(result); j++) {
    std::string str(CHAR(STRING_ELT(result, j)));
    ss_ret << escapeQuotes(str) << "\\n";
  }

  std::string ret =
      ss_ret.str();  //"find error";//Rcpp::as<std::string>(result);

  fims::FIMSLog::fims_log->error_message(log_entry, -1, "R_env", ret.c_str());
}
#endif  // FIMS_INTERFACE_RCPP_INTERFACE_HPP

/**
 * @file rcpp_data.hpp
 * @brief The Rcpp interface to declare different types of data, e.g.,
 * age-composition and index data. Allows for the use of methods::new() in R.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_DATA_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_DATA_HPP

#include "../../../common/information.hpp"
#include "rcpp_interface_base.hpp"

/**
 * @brief Rcpp interface that serves as the parent class for Rcpp data
 * interfaces. This type should be inherited and not called from R directly.
 */
class DataInterfaceBase : public FIMSRcppInterfaceBase {
 public:
  /**
   * @brief The vector of data that is being passed from R.
   */
  Rcpp::NumericVector observed_data;
  /**
   * @brief The vector of uncertainty that is being passed from R.
   */
  Rcpp::NumericVector uncertainty;
  /**
   * @brief The static id of the DataInterfaceBase object.
   */
  static uint32_t id_g;
  /**
   * @brief The local id of the DataInterfaceBase object.
   *
   */
  uint32_t id;
  /**
   * @brief The map associating the IDs of DataInterfaceBase to the objects.
   * This is a live object, which is an object that has been created and lives
   * in memory.
   */
  static std::map<uint32_t, std::shared_ptr<DataInterfaceBase>> live_objects;

  /**
   * @brief The constructor.
   */
  DataInterfaceBase() {
    this->id = DataInterfaceBase::id_g++;
    /* Create instance of map: key is id and value is pointer to
    DataInterfaceBase */
    // DataInterfaceBase::live_objects[this->id] = this;
  }

  /**
   * @brief Construct a new Data Interface Base object
   *
   * @param other
   */
  DataInterfaceBase(const DataInterfaceBase &other)
      : observed_data(other.observed_data),
        uncertainty(other.uncertainty),
        id(other.id) {}

  /**
   * @brief The destructor.
   */
  virtual ~DataInterfaceBase() {}

  /**
   * @brief Get the ID for the child data interface objects to inherit.
   */
  virtual uint32_t get_id() { return this->id; }

  /**
   * @brief Adds the parameters to the TMB model.
   */
  virtual bool add_to_fims_tmb() { return true; };
};
// static id of the DataInterfaceBase object
uint32_t DataInterfaceBase::id_g = 1;
// local id of the DataInterfaceBase object map relating the ID of the
// DataInterfaceBase to the DataInterfaceBase objects
std::map<uint32_t, std::shared_ptr<DataInterfaceBase>>
    DataInterfaceBase::live_objects;

/**
 * @brief  The Rcpp interface for AgeComp to instantiate the object from R:
 * acomp <- methods::new(AgeComp).
 */
class AgeCompDataInterface : public DataInterfaceBase {
 public:
  /**
   * @brief The first dimension of the data, which relates to the number of age
   * bins.
   */
  fims_int amax = 0;
  /**
   * @brief The second dimension of the data, which relates to the number of
   * time steps or years.
   */
  fims_int ymax = 0;
  /**
   * @brief The vector of age-composition data that is being passed from R.
   */
  RealVector age_comp_data;
  /**
   * @brief The vector of age-composition uncertainty that is being passed from
   * R.
   */
  RealVector uncertainty;

  /**
   * @brief The constructor.
   */
  AgeCompDataInterface(int ymax = 0, int amax = 0) : DataInterfaceBase() {
    this->amax = amax;
    this->ymax = ymax;
    this->age_comp_data.resize(amax * ymax);
    this->uncertainty.resize(amax * ymax);
    DataInterfaceBase::live_objects[this->id] =
        std::make_shared<AgeCompDataInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        DataInterfaceBase::live_objects[this->id]);
  }

  /**
   * @brief Construct a new Age Comp Data Interface object
   *
   * @param other
   */
  AgeCompDataInterface(const AgeCompDataInterface &other)
      : DataInterfaceBase(other),
        amax(other.amax),
        ymax(other.ymax),
        age_comp_data(other.age_comp_data),
        uncertainty(other.uncertainty) {}

  /**
   * @brief The destructor.
   */
  virtual ~AgeCompDataInterface() {}

  /**
   * @brief Gets the ID of the interface base object.
   * @return The ID.
   */
  virtual uint32_t get_id() { return this->id; }

  /**
   * @brief Converts the data to json representation for the output.
   * @return A string is returned specifying that the module relates to the
   * data interface with age-composition data. It also returns the ID, the rank
   * of 2, the dimensions by printing ymax and amax, followed by the data values
   * themselves. This string is formatted for a json file.
   */
  virtual std::string to_json() {
    std::stringstream ss;

    ss << "{\n";
    ss << " \"name\": \"AgeComp\",\n";
    ss << " \"id\":" << this->id << ",\n";
    ss << " \"type\": \"data\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [" << "\"n_ages\", \"n_years\"" << "],\n";
    ss << "  \"dimensions\": [" << amax << ", " << ymax << "]\n},\n";
    ss << " \"value\": [";
    for (size_t i = 0; i < age_comp_data.size() - 1; i++) {
      ss << age_comp_data[i] << ", ";
    }
    ss << age_comp_data[age_comp_data.size() - 1] << "],\n";
    ss << "\"uncertainty\":[ ";
    for (size_t i = 0; i < uncertainty.size() - 1; i++) {
      ss << uncertainty[i] << ", ";
    }
    ss << uncertainty[uncertainty.size() - 1] << "]\n";
    ss << "}";
    return ss.str();
  }

#ifdef TMB_MODEL

  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_data_object::DataObject<Type>> age_comp_data =
        std::make_shared<fims_data_object::DataObject<Type>>(this->ymax,
                                                             this->amax);

    age_comp_data->id = this->id;
    for (int y = 0; y < ymax; y++) {
      for (int a = 0; a < amax; a++) {
        int i_age_year = y * amax + a;
        age_comp_data->at(y, a) = this->age_comp_data[i_age_year];
        age_comp_data->uncertainty[i_age_year] = this->uncertainty[i_age_year];
      }
    }

    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();

    info->data_objects[this->id] = age_comp_data;

    return true;
  }

  /**
   * @brief Adds the parameters to the TMB model.
   * @return A boolean of true.
   */
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();

    return true;
  }

#endif
};

/**
 * @brief The Rcpp interface for LengthComp to instantiate the object from R:
 * lcomp <- methods::new(LengthComp).
 */
class LengthCompDataInterface : public DataInterfaceBase {
 public:
  /**
   * @brief The first dimension of the data, which relates to the number of
   * length bins.
   */
  fims_int lmax = 0;
  /**
   * @brief The second dimension of the data, which relates to the number of
   * time steps or years.
   */
  fims_int ymax = 0;
  /**
   * @brief The vector of length-composition data that is being passed from R.
   */
  RealVector length_comp_data;
  /**
   * @brief The vector of length-composition uncertainty that is being passed
   * from R.
   */
  RealVector uncertainty;

  /**
   * @brief The constructor.
   */
  LengthCompDataInterface(int ymax = 0, int lmax = 0) : DataInterfaceBase() {
    this->lmax = lmax;
    this->ymax = ymax;
    this->length_comp_data.resize(lmax * ymax);
    this->uncertainty.resize(lmax * ymax);
    DataInterfaceBase::live_objects[this->id] =
        std::make_shared<LengthCompDataInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        DataInterfaceBase::live_objects[this->id]);
  }

  /**
   * @brief Construct a new Length Comp Data Interface object
   *
   * @param other
   */
  LengthCompDataInterface(const LengthCompDataInterface &other)
      : DataInterfaceBase(other),
        lmax(other.lmax),
        ymax(other.ymax),
        length_comp_data(other.length_comp_data),
        uncertainty(other.uncertainty) {}

  /**
   * @brief The destructor.
   */
  virtual ~LengthCompDataInterface() {}

  /**
   * @brief Gets the ID of the interface base object.
   * @return The ID.
   */
  virtual uint32_t get_id() { return this->id; }

  /**
   * @brief Converts the data to json representation for the output.
   * @return A string is returned specifying that the module relates to the
   * data interface with length-composition data. It also returns the ID, the
   * rank of 2, the dimensions by printing ymax and lmax, followed by the data
   * values themselves. This string is formatted for a json file.
   */
  virtual std::string to_json() {
    std::stringstream ss;

    ss << "{\n";
    ss << " \"name\": \"LengthComp\",\n";
    ss << " \"id\":" << this->id << ",\n";
    ss << " \"type\": \"data\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [" << "\"n_lengths\", \"n_years\"" << "],\n";
    ss << "  \"dimensions\": [" << lmax << ", " << ymax << "]\n},\n";
    ss << " \"value\": [";
    for (size_t i = 0; i < length_comp_data.size() - 1; i++) {
      ss << length_comp_data[i] << ", ";
    }
    ss << length_comp_data[length_comp_data.size() - 1] << "],\n";
    ss << "\"uncertainty\": [ ";
    for (size_t i = 0; i < uncertainty.size() - 1; i++) {
      ss << uncertainty[i] << ", ";
    }
    ss << uncertainty[uncertainty.size() - 1] << "]\n";
    ss << "}";
    return ss.str();
  }

#ifdef TMB_MODEL
  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_data_object::DataObject<Type>> length_comp_data =
        std::make_shared<fims_data_object::DataObject<Type>>(this->ymax,
                                                             this->lmax);
    length_comp_data->id = this->id;
    for (int y = 0; y < ymax; y++) {
      for (int l = 0; l < lmax; l++) {
        int i_length_year = y * lmax + l;
        length_comp_data->at(y, l) = this->length_comp_data[i_length_year];
        length_comp_data->uncertainty[i_length_year] =
            this->uncertainty[i_length_year];
      }
    }
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();
    info->data_objects[this->id] = length_comp_data;
    return true;
  }

  /**
   * @brief Adds the parameters to the TMB model.
   * @return A boolean of true.
   */
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();

    return true;
  }
#endif
};

/**
 * @brief  The Rcpp interface for Index to instantiate the object from R:
 * fleet <- methods::new(Index).
 */
class IndexDataInterface : public DataInterfaceBase {
 public:
  /**
   * @brief An integer that specifies the second dimension of the data.
   */
  fims_int ymax = 0;
  /**
   * @brief The vector of index data that is being passed from R.
   */
  RealVector index_data;
  /**
   * @brief The vector of index uncertainty that is being passed from
   * R.
   */
  RealVector uncertainty;

  /**
   * @brief The constructor.
   */
  IndexDataInterface(int ymax = 0) : DataInterfaceBase() {
    this->ymax = ymax;
    this->index_data.resize(ymax);
    this->uncertainty.resize(ymax);
    DataInterfaceBase::live_objects[this->id] =
        std::make_shared<IndexDataInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        DataInterfaceBase::live_objects[this->id]);
  }

  /**
   * @brief Construct a new Index Data Interface object
   *
   * @param other
   */
  IndexDataInterface(const IndexDataInterface &other)
      : DataInterfaceBase(other),
        ymax(other.ymax),
        index_data(other.index_data),
        uncertainty(other.uncertainty) {}

  /**
   * @brief The destructor.
   */
  virtual ~IndexDataInterface() {}

  /**
   * @brief Gets the ID of the interface base object.
   * @return The ID.
   */
  virtual uint32_t get_id() { return this->id; }

  /**
   * @brief Converts the data to json representation for the output.
   * @return A string is returned specifying that the module relates to the
   * data interface with index data. It also returns the ID, the rank of 1, the
   * dimensions by printing ymax, followed by the data values themselves. This
   * string is formatted for a json file.
   */
  virtual std::string to_json() {
    std::stringstream ss;

    ss << "{\n";
    ss << " \"name\": \"Index\",\n";
    ss << " \"id\": " << this->id << ",\n";
    ss << " \"type\": \"data\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [" << "\"n_years\"" << "],\n";
    ss << "  \"dimensions\": [" << ymax << "]\n},\n";
    ss << " \"value\": [";
    for (size_t i = 0; i < index_data.size() - 1; i++) {
      ss << index_data[i] << ", ";
    }
    ss << index_data[index_data.size() - 1] << "],\n";
    ss << "\"uncertainty\": [ ";
    for (size_t i = 0; i < uncertainty.size() - 1; i++) {
      ss << uncertainty[i] << ", ";
    }
    ss << uncertainty[uncertainty.size() - 1] << "]\n";
    ss << "}";
    return ss.str();
  }

#ifdef TMB_MODEL

  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_data_object::DataObject<Type>> data =
        std::make_shared<fims_data_object::DataObject<Type>>(this->ymax);

    data->id = this->id;

    for (int y = 0; y < ymax; y++) {
      data->at(y) = this->index_data[y];
      data->uncertainty[y] = this->uncertainty[y];
    }

    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();

    info->data_objects[this->id] = data;
    return true;
  }

  /**
   * @brief Adds the parameters to the TMB model.
   * @return A boolean of true.
   */
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();

    return true;
  }

#endif
};

/**
 * @brief  The Rcpp interface for Landings to instantiate the object from R:
 * fleet <- methods::new(Landings).
 */
class LandingsDataInterface : public DataInterfaceBase {
 public:
  /**
   * @brief An integer that specifies the second dimension of the data.
   */
  fims_int ymax = 0;
  /**
   * @brief The vector of landings data that is being passed from R.
   */
  RealVector landings_data;
  /**
   * @brief The vector of landings uncertainty that is being passed from
   * R.
   */
  RealVector uncertainty;

  /**
   * @brief The constructor.
   */
  LandingsDataInterface(int ymax = 0) : DataInterfaceBase() {
    this->ymax = ymax;
    this->landings_data.resize(ymax);
    this->uncertainty.resize(ymax);
    DataInterfaceBase::live_objects[this->id] =
        std::make_shared<LandingsDataInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        DataInterfaceBase::live_objects[this->id]);
  }

  /**
   * @brief Construct a new Landings Data Interface object
   *
   * @param other
   */
  LandingsDataInterface(const LandingsDataInterface &other)
      : DataInterfaceBase(other),
        ymax(other.ymax),
        landings_data(other.landings_data),
        uncertainty(other.uncertainty) {}

  /**
   * @brief The destructor.
   */
  virtual ~LandingsDataInterface() {}

  /**
   * @brief Gets the ID of the interface base object.
   * @return The ID.
   */
  virtual uint32_t get_id() { return this->id; }

  /**
   * @brief Converts the data to json representation for the output.
   * @return A string is returned specifying that the module relates to the
   * data interface with landings data. It also returns the ID, the rank of 1,
   * the dimensions by printing ymax, followed by the data values themselves.
   * This string is formatted for a json file.
   */
  virtual std::string to_json() {
    std::stringstream ss;

    ss << "{\n";
    ss << " \"name\": \"Landings\",\n";
    ss << " \"id\": " << this->id << ",\n";
    ss << " \"type\": \"data\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [" << "\"n_years\"" << "],\n";
    ss << "  \"dimensions\": [" << ymax << "]\n},\n";
    ss << " \"value\": [";
    for (size_t i = 0; i < landings_data.size() - 1; i++) {
      ss << landings_data[i] << ", ";
    }
    ss << landings_data[landings_data.size() - 1] << "],\n";
    ss << "\"uncertainty\": [ ";
    for (size_t i = 0; i < uncertainty.size() - 1; i++) {
      ss << uncertainty[i] << ", ";
    }
    ss << uncertainty[uncertainty.size() - 1] << "]\n";
    ss << "}";
    return ss.str();
  }

#ifdef TMB_MODEL

  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_data_object::DataObject<Type>> data =
        std::make_shared<fims_data_object::DataObject<Type>>(this->ymax);

    data->id = this->id;

    for (int y = 0; y < ymax; y++) {
      data->at(y) = this->landings_data[y];
      data->uncertainty[y] = this->uncertainty[y];
    }

    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();

    info->data_objects[this->id] = data;
    return true;
  }

  /**
   * @brief Adds the parameters to the TMB model.
   * @return A boolean of true.
   */
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();

    return true;
  }

#endif
};

#endif

/**
 * @file rcpp_distribution.hpp
 * @brief The Rcpp interface to declare different distributions, e.g.,
 * normal and log normal. Allows for the use of methods::new() in R.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_DISTRIBUTION_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_DISTRIBUTION_HPP

#include "../../../distributions/distributions.hpp"
#include "../../interface.hpp"
#include "rcpp_interface_base.hpp"

/**
 * @brief Rcpp interface that serves as the parent class for Rcpp distribution
 * interfaces. This type should be inherited and not called from R directly.
 */
class DistributionsInterfaceBase : public FIMSRcppInterfaceBase {
 public:
  /**
   * @brief The static ID of the DistributionsInterfaceBase object.
   */
  static uint32_t id_g;
  /**
   * @brief The local ID of the DistributionsInterfaceBase object.
   */
  uint32_t id_m;
  /**
   * @brief The unique ID for the variable map that points to a fims::Vector.
   */
  std::shared_ptr<std::vector<uint32_t>> key_m;
  /**
   * @brief The type of density input. The options are prior, re, or data.
   */
  SharedString input_type_m;
  /**
   * @brief Control flag indicating whether to use the expected mean in the
   * distribution calculations.
   *
   * This shared string member serves as a boolean flag (i.e., "yes" or "no")
   * that determines whether the distribution should use the `expected_mean`
   * vector or other expected values (e.g., from data or random effects) when
   * computing the expected value in the likelihood calculations.
   *
   * When set to "no" (default), the distribution uses expected values based on
   * the `input_type` setting (data expected values for "data", random effects
   * expected values for "random_effects", or standard expected values
   * otherwise).
   *
   * When set to "yes" (typically by calling `set_distribution_mean()`), the
   * distribution overrides the default expected value source and uses the
   * `expected_mean` vector instead. This is useful for setting a fixed mean
   * value for the distribution that doesn't depend on other model components.
   *
   * @see set_distribution_mean() for the method that sets this flag to "yes".
   * @see DensityComponentBase::get_expected() in density_components_base.hpp
   * for the implementation that checks this flag.
   */
  SharedString use_mean_m = fims::to_string("no");
  /**
   * @brief The map associating the ID of the DistributionsInterfaceBase to the
     DistributionsInterfaceBase objects. This is a live object, which is an
     object that has been created and lives in memory.
   */
  static std::map<uint32_t, std::shared_ptr<DistributionsInterfaceBase>>
      live_objects;
  /**
   * @brief The ID of the observed data object, which is set to -999.
   */
  SharedInt interface_observed_data_id_m = -999;

  /**
   * @brief The log probability density function value.
   */
  double lpdf_value = 0;
  /**
   * @brief The constructor.
   */
  DistributionsInterfaceBase() {
    this->key_m = std::make_shared<std::vector<uint32_t>>();
    this->id_m = DistributionsInterfaceBase::id_g++;
    /* Create instance of map: key is id and value is pointer to
    DistributionsInterfaceBase */
    // DistributionsInterfaceBase::live_objects[this->id_m] = this;
  }

  /**
   * @brief Construct a new Distributions Interface Base object
   *
   * @param other
   */
  DistributionsInterfaceBase(const DistributionsInterfaceBase &other)
      : id_m(other.id_m),
        key_m(other.key_m),
        input_type_m(other.input_type_m),
        use_mean_m(other.use_mean_m),
        interface_observed_data_id_m(other.interface_observed_data_id_m) {}

  /**
   * @brief The destructor.
   */
  virtual ~DistributionsInterfaceBase() {}

  /**
   * @brief Get the ID for the child distribution interface objects to inherit.
   */
  virtual uint32_t get_id() = 0;

  /**
   * @brief Sets pointers for data observations, random effects, or priors.
   *
   * @param input_type String that sets whether the distribution type is for
   * priors, random effects, or data.
   * @param ids Vector of unique ids for each linked parameter(s), derived
   * value(s), or observed data vector.
   */
  virtual bool set_distribution_links(std::string input_type,
                                      Rcpp::IntegerVector ids) {
    return false;
  }

  /**
   * @brief Set the expected mean value for the distribution.
   *
   * This virtual function provides an interface for setting a fixed mean value
   * for distribution objects. When overridden in derived classes, this method
   * typically stores the provided mean value as a fixed effect parameter and
   * marks the distribution to use the mean in its calculations.
   *
   * The base class implementation returns false to indicate the operation is
   * not supported. Derived classes that support mean specification should
   * override this method to implement the actual functionality.
   *
   * @param input_value The numeric value to set as the distribution's expected
   * mean. This value will be treated as a fixed effect parameter (not
   * estimated) in derived class implementations.
   *
   * @return bool Returns true if the mean was successfully set, false
   * otherwise. The base class implementation always returns false to indicate
   * the operation is not supported by default.
   *
   * @see DnormDistributionsInterface::set_distribution_mean for an example
   * implementation that sets the mean as a fixed effect parameter.
   */
  virtual bool set_distribution_mean(double input_value) { return false; }

  /**
   * @brief Set the unique ID for the observed data object.
   *
   * @param observed_data_id Unique ID for the Observed Age Comp Data
   * object
   */
  virtual bool set_observed_data(int observed_data_id) { return false; }

  /**
   * @brief A method for each child distribution interface object to inherit so
   * each distribution can have an evaluate() function.
   */
  virtual double evaluate() = 0;
};
// static id of the DistributionsInterfaceBase object
uint32_t DistributionsInterfaceBase::id_g = 1;
// local id of the DistributionsInterfaceBase object map relating the ID of the
// DistributionsInterfaceBase to the DistributionsInterfaceBase objects
std::map<uint32_t, std::shared_ptr<DistributionsInterfaceBase>>
    DistributionsInterfaceBase::live_objects;

/**
 * @brief The Rcpp interface for Dnorm to instantiate from R:
 * dnorm_ <- methods::new(DnormDistribution).
 */
class DnormDistributionsInterface : public DistributionsInterfaceBase {
 public:
  /**
   * @brief Observed data.
   */
  ParameterVector observed_values;
  /**
   * @brief The expected values, which would be the mean of x for this
   * distribution.
   */
  ParameterVector expected_values;
  /**
   * @brief The expected mean, which would be the mean of x for this
   * distribution.
   */
  ParameterVector expected_mean;
  /**
   * @brief The uncertainty, which would be the standard deviation of x for the
   * normal distribution.
   */
  ParameterVector log_sd;
  /**
   * @brief Vector that records the individual log probability function for each
   * observation.
   */
  RealVector lpdf_vec; /**< The vector*/

  /**
   * @brief The constructor.
   */
  DnormDistributionsInterface() : DistributionsInterfaceBase() {
    DistributionsInterfaceBase::live_objects[this->id_m] =
        std::make_shared<DnormDistributionsInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        DistributionsInterfaceBase::live_objects[this->id_m]);
  }

  /**
   * @brief Construct a new Dnorm Distributions Interface object
   *
   * @param other
   */
  DnormDistributionsInterface(const DnormDistributionsInterface &other)
      : DistributionsInterfaceBase(other),
        observed_values(other.observed_values),
        expected_values(other.expected_values),
        expected_mean(other.expected_mean),
        log_sd(other.log_sd),
        lpdf_vec(other.lpdf_vec) {}

  /**
   * @brief The destructor.
   */
  virtual ~DnormDistributionsInterface() {}

  /**
   * @brief Gets the ID of the interface base object.
   * @return The ID.
   */
  virtual uint32_t get_id() { return this->id_m; }

  /**
   * @brief Set the unique ID for the observed data object.
   * @param observed_data_id Unique ID for the observed data object.
   */
  virtual bool set_observed_data(int observed_data_id) {
    this->interface_observed_data_id_m.set(observed_data_id);
    return true;
  }

  /**
   * @copydoc DistributionsInterfaceBase::set_distribution_mean
   */
  virtual bool set_distribution_mean(double input_value) {
    this->expected_mean[0].initial_value_m = input_value;
    this->expected_mean[0].estimation_type_m.set("fixed_effects");
    this->use_mean_m.set(fims::to_string("yes"));
    return true;
  }

  /**
   * @copydoc DistributionsInterfaceBase::set_distribution_links
   */
  virtual bool set_distribution_links(std::string input_type,
                                      Rcpp::IntegerVector ids) {
    this->input_type_m.set(input_type);
    this->key_m->resize(ids.size());
    for (R_xlen_t i = 0; i < ids.size(); i++) {
      this->key_m->at(i) = ids[i];
    }
    return true;
  }

  /**
   * @brief Evaluate normal probability density function (pdf). The natural log
   * of the pdf is returned.
   * @return The natural log of the probability density function (pdf) is
   * returned.
   */
  virtual double evaluate() {
    fims_distributions::NormalLPDF<double> dnorm;
    dnorm.observed_values.resize(this->observed_values.size());
    dnorm.expected_values.resize(this->expected_values.size());
    dnorm.log_sd.resize(this->log_sd.size());
    dnorm.expected_mean.resize(this->expected_mean.size());
    for (size_t i = 0; i < this->observed_values.size(); i++) {
      dnorm.observed_values[i] = this->observed_values[i].initial_value_m;
    }
    for (size_t i = 0; i < this->expected_values.size(); i++) {
      dnorm.expected_values[i] = this->expected_values[i].initial_value_m;
    }
    for (size_t i = 0; i < this->log_sd.size(); i++) {
      dnorm.log_sd[i] = this->log_sd[i].initial_value_m;
    }
    for (size_t i = 0; i < this->expected_mean.size(); i++) {
      dnorm.expected_mean[i] = this->expected_mean[i].initial_value_m;
    }
    dnorm.use_mean = this->use_mean_m;
    return dnorm.evaluate();
  }

  /**
   * @brief Extracts the derived quantities from `Information` to the Rcpp
   * object.
   */
  virtual void finalize() {
    if (this->finalized) {
      // log warning that finalize has been called more than once.
      FIMS_WARNING_LOG("DnormDistribution  " + fims::to_string(this->id_m) +
                       " has been finalized already.");
    }

    this->finalized = true;  // indicate this has been called already

    std::shared_ptr<fims_info::Information<double>> info =
        fims_info::Information<double>::GetInstance();

    fims_info::Information<double>::density_components_iterator it;

    // search for density component in Information
    it = info->density_components.find(this->id_m);
    // if not found, just return
    if (it == info->density_components.end()) {
      FIMS_WARNING_LOG("DnormDistribution " + fims::to_string(this->id_m) +
                       " not found in Information.");
      return;
    } else {
      std::shared_ptr<fims_distributions::NormalLPDF<double>> dnorm =
          std::dynamic_pointer_cast<fims_distributions::NormalLPDF<double>>(
              it->second);

      this->lpdf_value = dnorm->lpdf;

      size_t n_x = dnorm->get_n_x();

      // If input log_sd is a scalar, resize to n_x and fill with the scalar
      // value
      if (this->log_sd.size() != n_x) {
        // If log_sd size == 1 (scalar), repeat the entry
        if (this->log_sd.size() == 1) {
          auto tmp = this->log_sd[0];  // copy the one log_sd param
          this->log_sd.resize(n_x);
          for (size_t i = 0; i < n_x; ++i) {
            this->log_sd[i] = tmp;  // copies all fields in Param
          }
        } else {
          // Handle error
          FIMS_WARNING_LOG(
              "log_sd size does not match number of observations and is not "
              "scalar.");
        }
      }
      for (size_t i = 0; i < n_x; i++) {
        if (this->log_sd[i].estimation_type_m.get() == "constant") {
          this->log_sd[i].final_value_m = this->log_sd[i].initial_value_m;
        } else {
          this->log_sd[i].final_value_m = dnorm->log_sd.get_force_scalar(i);
        }
      }

      for (size_t i = 0; i < this->expected_mean.size(); i++) {
        if (this->expected_mean[i].estimation_type_m.get() == "constant") {
          this->expected_mean[i].final_value_m =
              this->expected_mean[i].initial_value_m;
        } else {
          this->expected_mean[i].final_value_m = dnorm->expected_mean[i];
        }
      }

      this->lpdf_vec = RealVector(n_x);
      if (this->expected_values.size() == 1) {
        this->expected_values.resize(n_x);
      }
      if (this->observed_values.size() == 1) {
        this->observed_values.resize(n_x);
      }

      for (size_t i = 0; i < this->lpdf_vec.size(); i++) {
        this->lpdf_vec[i] = dnorm->lpdf_vec[i];
        this->expected_values[i].final_value_m = dnorm->get_expected(i);
        this->observed_values[i].final_value_m = dnorm->get_observed(i);
      }
    }
  }

  /**
   * @brief Converts the data to json representation for the output.
   * @return A string is returned specifying that the module relates to the
   * distribution interface with a normal distribution. It also returns the ID
   * and the natural log of the probability density function values themselves.
   * This string is formatted for a json file.
   */
  virtual std::string to_json() {
    std::stringstream ss;

    ss << "{\n";
    ss << " \"module_name\": \"density\",\n";
    ss << " \"module_id\": " << this->id_m << ",\n";
    ss << " \"module_type\": \"normal\",\n";
    ss << " \"observed_data_id\" : " << this->interface_observed_data_id_m
       << ",\n";
    ss << " \"input_type\" : \"" << this->input_type_m << "\",\n";
    ss << " \"density_component\": {\n";
    ss << "  \"lpdf_value\": " << this->lpdf_value << ",\n";
    ss << "  \"value\":[";
    if (this->lpdf_vec.size() == 0) {
      ss << "],\n";
    } else {
      for (size_t i = 0; i < this->lpdf_vec.size() - 1; i++) {
        ss << this->value_to_string(this->lpdf_vec[i]);
        ss << ", ";
      }
      ss << this->value_to_string(this->lpdf_vec[this->lpdf_vec.size() - 1]);

      ss << "],\n";
    }
    ss << "  \"expected_values\":[";
    if (this->expected_values.size() == 0) {
      ss << "],\n";
    } else {
      for (size_t i = 0; i < this->expected_values.size() - 1; i++) {
        ss << this->value_to_string(this->expected_values[i].final_value_m)
           << ", ";
      }
      ss << this->value_to_string(
          this->expected_values[this->expected_values.size() - 1]
              .final_value_m);
      ss << "],\n";
    }
    ss << "  \"log_sd_values\":[";
    if (this->log_sd.size() == 0) {
      ss << "],\n";
    } else {
      for (R_xlen_t i = 0; i < static_cast<R_xlen_t>(this->log_sd.size()) - 1;
           i++) {
        ss << this->value_to_string(this->log_sd[i].final_value_m) << ", ";
      }
      ss << this->value_to_string(
                this->log_sd[this->log_sd.size() - 1].final_value_m)
         << "],\n";
    }
    ss << "  \"observed_values\":[";
    if (this->observed_values.size() == 0) {
      ss << "]\n";
    } else {
      for (size_t i = 0; i < this->observed_values.size() - 1; i++) {
        ss << this->observed_values[i].final_value_m << ", ";
      }
      ss << this->observed_values[this->observed_values.size() - 1]
                .final_value_m
         << "]\n";
    }
    ss << " }}\n";
    return ss.str();
  }

#ifdef TMB_MODEL

  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();

    std::shared_ptr<fims_distributions::NormalLPDF<Type>> distribution =
        std::make_shared<fims_distributions::NormalLPDF<Type>>();

    // interface to data/parameter value

    distribution->observed_data_id_m = interface_observed_data_id_m;
    std::stringstream ss;
    distribution->input_type = this->input_type_m;
    distribution->key.resize(this->key_m->size());
    for (size_t i = 0; i < this->key_m->size(); i++) {
      distribution->key[i] = this->key_m->at(i);
    }
    distribution->id = this->id_m;
    distribution->observed_values.resize(this->observed_values.size());
    for (size_t i = 0; i < this->observed_values.size(); i++) {
      distribution->observed_values[i] =
          this->observed_values[i].initial_value_m;
    }
    // set relative info
    distribution->expected_values.resize(this->expected_values.size());
    for (size_t i = 0; i < this->expected_values.size(); i++) {
      distribution->expected_values[i] =
          this->expected_values[i].initial_value_m;
    }
    distribution->log_sd.resize(this->log_sd.size());
    for (size_t i = 0; i < this->log_sd.size(); i++) {
      distribution->log_sd[i] = this->log_sd[i].initial_value_m;
      if (this->log_sd[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "dnorm." << this->id_m << ".log_sd." << this->log_sd[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(distribution->log_sd[i]);
      }
      if (this->log_sd[i].estimation_type_m.get() == "random_effects") {
        FIMS_ERROR_LOG("standard deviations cannot be set to random effects");
      }
    }
    info->variable_map[this->log_sd.id_m] = &(distribution)->log_sd;

    distribution->use_mean = this->use_mean_m.get();
    distribution->expected_mean.resize(this->expected_mean.size());
    for (size_t i = 0; i < this->expected_mean.size(); i++) {
      distribution->expected_mean[i] = this->expected_mean[i].initial_value_m;
      if (this->expected_mean[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "dnorm." << this->id_m << ".expected_mean."
           << this->expected_mean[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(distribution->expected_mean[i]);
      }
      if (this->expected_mean[i].estimation_type_m.get() == "random_effects") {
        FIMS_ERROR_LOG("expected_mean cannot be set to random effects");
      }
    }
    info->variable_map[this->expected_mean.id_m] =
        &(distribution)->expected_mean;

    info->density_components[distribution->id] = distribution;

    return true;
  }

  /**
   * @brief Adds the parameters to the TMB model.
   * @return A boolean of true.
   */
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();

    return true;
  }

#endif
};

/**
 * @brief The Rcpp interface for Dlnorm to instantiate from R:
 * dlnorm_ <- methods::new(DlnormDistribution).
 */
class DlnormDistributionsInterface : public DistributionsInterfaceBase {
 public:
  /**
   * @brief Observed data.
   */
  ParameterVector observed_values;
  /**
   * @brief The expected values, which would be the mean of log(x) for this
   * distribution.
   */
  ParameterVector expected_values;
  /**
   * @brief The uncertainty, which would be the natural logarithm of the
     standard deviation (sd) of log(x) for this distribution. The natural log
     of the standard deviation is necessary because the exponential link
     function is applied to the log transformed standard deviation to insure
     standard deviation is positive.
   */
  ParameterVector log_sd;
  /**
   * @brief Vector that records the individual log probability function for each
   * observation.
   */
  RealVector lpdf_vec; /**< The vector */

  /**
   * @brief The constructor.
   */
  DlnormDistributionsInterface() : DistributionsInterfaceBase() {
    DistributionsInterfaceBase::live_objects[this->id_m] =
        std::make_shared<DlnormDistributionsInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        DistributionsInterfaceBase::live_objects[this->id_m]);
  }

  /**
   * @brief Construct a new Dlnorm Distributions Interface object
   *
   * @param other
   */
  DlnormDistributionsInterface(const DlnormDistributionsInterface &other)
      : DistributionsInterfaceBase(other),
        observed_values(other.observed_values),
        expected_values(other.expected_values),
        log_sd(other.log_sd),
        lpdf_vec(other.lpdf_vec) {}

  /**
   * @brief The destructor.
   */
  virtual ~DlnormDistributionsInterface() {}

  /**
   * @brief Gets the ID of the interface base object.
   * @return The ID.
   */
  virtual uint32_t get_id() { return this->id_m; }

  /**
   * @brief Set the unique ID for the observed data object.
   * @param observed_data_id Unique ID for the observed data object.
   */
  virtual bool set_observed_data(int observed_data_id) {
    this->interface_observed_data_id_m.set(observed_data_id);
    return true;
  }

  /**
   * @brief Sets pointers for data observations, random effects, or priors.
   *
   * @param input_type String that sets whether the distribution type is for
   * priors, random effects, or data.
   * @param ids Vector of unique ids for each linked parameter(s), derived
   * value(s), or observed data vector.
   */
  virtual bool set_distribution_links(std::string input_type,
                                      Rcpp::IntegerVector ids) {
    this->input_type_m.set(input_type);
    this->key_m->resize(ids.size());
    for (R_xlen_t i = 0; i < ids.size(); i++) {
      this->key_m->at(i) = ids[i];
    }
    return true;
  }

  /**
   * @brief Evaluate lognormal probability density function (pdf). The natural
   * log of the pdf is returned.
   * @return The natural log of the probability density function (pdf) is
   * returned.
   */
  virtual double evaluate() {
    fims_distributions::LogNormalLPDF<double> dlnorm;
    dlnorm.observed_values.resize(this->observed_values.size());
    dlnorm.expected_values.resize(this->expected_values.size());
    dlnorm.log_sd.resize(this->log_sd.size());
    // dlnorm.input_type = "prior";
    for (size_t i = 0; i < this->observed_values.size(); i++) {
      dlnorm.observed_values[i] = this->observed_values[i].initial_value_m;
    }
    for (size_t i = 0; i < this->expected_values.size(); i++) {
      dlnorm.expected_values[i] = this->expected_values[i].initial_value_m;
    }
    for (size_t i = 0; i < this->log_sd.size(); i++) {
      dlnorm.log_sd[i] = this->log_sd[i].initial_value_m;
    }
    return dlnorm.evaluate();
  }

  /**
   * @brief Extracts the derived quantities from `Information` to the Rcpp
   * object.
   */
  virtual void finalize() {
    if (this->finalized) {
      // log warning that finalize has been called more than once.
      FIMS_WARNING_LOG("LogNormalLPDF  " + fims::to_string(this->id_m) +
                       " has been finalized already.");
    }

    this->finalized = true;  // indicate this has been called already

    std::shared_ptr<fims_info::Information<double>> info =
        fims_info::Information<double>::GetInstance();

    fims_info::Information<double>::density_components_iterator it;

    // search for density component in Information
    it = info->density_components.find(this->id_m);
    // if not found, just return
    if (it == info->density_components.end()) {
      FIMS_WARNING_LOG("LogNormalLPDF " + fims::to_string(this->id_m) +
                       " not found in Information.");
      return;
    } else {
      std::shared_ptr<fims_distributions::LogNormalLPDF<double>> dlnorm =
          std::dynamic_pointer_cast<fims_distributions::LogNormalLPDF<double>>(
              it->second);

      this->lpdf_value = dlnorm->lpdf;

      size_t n_x = dlnorm->get_n_x();

      if (this->log_sd.size() != n_x) {
        // If log_sd size == 1 (scalar), repeat the entry
        if (this->log_sd.size() == 1) {
          auto tmp = this->log_sd[0];  // copy the one log_sd param
          this->log_sd.resize(n_x);
          for (size_t i = 0; i < n_x; ++i) {
            this->log_sd[i] = tmp;  // copies all fields in Param
          }
        } else {
          // Handle error
          FIMS_WARNING_LOG(
              "log_sd size does not match number of observations and is not "
              "scalar.");
        }
      }

      for (size_t i = 0; i < n_x; i++) {
        if (this->log_sd[i].estimation_type_m.get() == "constant") {
          this->log_sd[i].final_value_m = this->log_sd[i].initial_value_m;
        } else {
          this->log_sd[i].final_value_m = dlnorm->log_sd.get_force_scalar(i);
        }
      }

      this->lpdf_vec = RealVector(n_x);
      if (this->expected_values.size() == 1) {
        this->expected_values.resize(n_x);
      }
      if (this->observed_values.size() == 1) {
        this->observed_values.resize(n_x);
      }
      for (size_t i = 0; i < this->lpdf_vec.size(); i++) {
        this->lpdf_vec[i] = dlnorm->lpdf_vec[i];
        this->expected_values[i].final_value_m = dlnorm->get_expected(i);
        this->observed_values[i].final_value_m = dlnorm->get_observed(i);
      }
    }
  }

  /**
   * @brief Converts the data to json representation for the output.
   * @return A string is returned specifying that the module relates to the
   * distribution interface with a log_normal distribution. It also returns the
   * ID and the natural log of the probability density function values
   * themselves. This string is formatted for a json file.
   */
  virtual std::string to_json() {
    std::stringstream ss;

    ss << "{\n";
    ss << " \"module_name\": \"density\",\n";
    ss << " \"module_id\": " << this->id_m << ",\n";
    ss << " \"module_type\": \"log_normal\",\n";
    ss << " \"observed_data_id\" : " << this->interface_observed_data_id_m
       << ",\n";
    ss << " \"input_type\" : \"" << this->input_type_m << "\",\n";
    ss << " \"density_component\": {\n";
    ss << "  \"lpdf_value\": " << this->lpdf_value << ",\n";
    ss << "  \"value\":[";
    if (this->lpdf_vec.size() == 0) {
      ss << "],\n";
    } else {
      for (size_t i = 0; i < this->lpdf_vec.size() - 1; i++) {
        ss << this->value_to_string(this->lpdf_vec[i]) << ", ";
      }
      ss << this->value_to_string(this->lpdf_vec[this->lpdf_vec.size() - 1]);

      ss << "],\n";
    }
    ss << "  \"expected_values\":[";
    if (this->expected_values.size() == 0) {
      ss << "],\n";
    } else {
      for (size_t i = 0; i < this->expected_values.size() - 1; i++) {
        ss << this->value_to_string(this->expected_values[i].final_value_m)
           << ", ";
      }
      ss << this->value_to_string(
          this->expected_values[this->expected_values.size() - 1]
              .final_value_m);

      ss << "],\n";
    }
    ss << "  \"log_sd_values\":[";
    if (this->log_sd.size() == 0) {
      ss << "],\n";
    } else {
      for (R_xlen_t i = 0; i < static_cast<R_xlen_t>(this->log_sd.size()) - 1;
           i++) {
        ss << this->value_to_string(this->log_sd[i].final_value_m) << ", ";
      }
      ss << this->value_to_string(
                this->log_sd[this->log_sd.size() - 1].final_value_m)
         << "],\n";
    }
    ss << "  \"observed_values\":[";
    if (this->observed_values.size() == 0) {
      ss << "]\n";
    } else {
      for (size_t i = 0; i < this->observed_values.size() - 1; i++) {
        ss << this->observed_values[i].final_value_m << ", ";
      }
      ss << this->observed_values[this->observed_values.size() - 1]
                .final_value_m
         << "]\n";
    }
    ss << " }}\n";
    return ss.str();
  }

#ifdef TMB_MODEL

  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();

    std::shared_ptr<fims_distributions::LogNormalLPDF<Type>> distribution =
        std::make_shared<fims_distributions::LogNormalLPDF<Type>>();

    // set relative info
    distribution->id = this->id_m;
    std::stringstream ss;
    distribution->observed_data_id_m = interface_observed_data_id_m;
    distribution->input_type = this->input_type_m;
    distribution->key.resize(this->key_m->size());
    for (size_t i = 0; i < this->key_m->size(); i++) {
      distribution->key[i] = this->key_m->at(i);
    }
    distribution->observed_values.resize(this->observed_values.size());
    for (size_t i = 0; i < this->observed_values.size(); i++) {
      distribution->observed_values[i] =
          this->observed_values[i].initial_value_m;
    }
    // set relative info
    distribution->expected_values.resize(this->expected_values.size());
    for (size_t i = 0; i < this->expected_values.size(); i++) {
      distribution->expected_values[i] =
          this->expected_values[i].initial_value_m;
    }
    distribution->log_sd.resize(this->log_sd.size());
    for (size_t i = 0; i < this->log_sd.size(); i++) {
      distribution->log_sd[i] = this->log_sd[i].initial_value_m;
      if (this->log_sd[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "dlnorm." << this->id_m << ".log_sd." << this->log_sd[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(distribution->log_sd[i]);
      }
      if (this->log_sd[i].estimation_type_m.get() == "random_effects") {
        FIMS_ERROR_LOG("standard deviations cannot be set to random effects");
      }
    }
    info->variable_map[this->log_sd.id_m] = &(distribution)->log_sd;

    info->density_components[distribution->id] = distribution;

    return true;
  }

  /**
   * @brief Adds the parameters to the TMB model.
   * @return A boolean of true.
   */
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();

    return true;
  }

#endif
};

/**
 * @brief The Rcpp interface for Dmultinom to instantiate from R:
 * dmultinom_ <- methods::new(DmultinomDistribution).
 */
class DmultinomDistributionsInterface : public DistributionsInterfaceBase {
 public:
  /**
   * @brief Observed data, which should be a vector of length K of integers.
   */
  ParameterVector observed_values;
  /**
   * @brief The expected values, which should be a vector of length K where
   * each value specifies the probability of class k. Note that, unlike in R,
   * these probabilities must sum to 1.0.
   */
  ParameterVector expected_values;
  /**
   * @brief The dimensions of the number of rows and columns of the
   * multivariate dataset.
   */
  RealVector dims;
  /**
   * @brief Vector that records the individual log probability function for each
   * observation.
   */
  RealVector lpdf_vec; /**< The vector */

  /**
   * @brief TODO: document this.
   *
   */
  SharedString notes;

  /**
   * @brief The constructor.
   */
  DmultinomDistributionsInterface() : DistributionsInterfaceBase() {
    DistributionsInterfaceBase::live_objects[this->id_m] =
        std::make_shared<DmultinomDistributionsInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        DistributionsInterfaceBase::live_objects[this->id_m]);
  }

  /**
   * @brief Construct a new Dmultinom Distributions Interface object
   *
   * @param other
   */
  DmultinomDistributionsInterface(const DmultinomDistributionsInterface &other)
      : DistributionsInterfaceBase(other),
        observed_values(other.observed_values),
        expected_values(other.expected_values),
        dims(other.dims),
        lpdf_vec(other.lpdf_vec),
        notes(other.notes) {}

  /**
   * @brief The destructor.
   */
  virtual ~DmultinomDistributionsInterface() {}
  /**
   * @brief Gets the ID of the interface base object.
   * @return The ID.
   */
  virtual uint32_t get_id() { return this->id_m; }

  /**
   * @brief Set the unique ID for the observed data object.
   * @param observed_data_id Unique ID for the observed data object.
   */
  virtual bool set_observed_data(int observed_data_id) {
    this->interface_observed_data_id_m.set(observed_data_id);
    return true;
  }

  /**
   * @brief Sets pointers for data observations, random effects, or priors.
   *
   * @param input_type String that sets whether the distribution type is for
   * priors, random effects, or data.
   * @param ids Vector of unique ids for each linked parameter(s), derived
   * value(s), or observed data vector.
   */
  virtual bool set_distribution_links(std::string input_type,
                                      Rcpp::IntegerVector ids) {
    this->input_type_m.set(input_type);
    this->key_m->resize(ids.size());
    for (R_xlen_t i = 0; i < ids.size(); i++) {
      this->key_m->at(i) = ids[i];
    }
    return true;
  }

  /**
   * @brief Set the note object
   *
   * @param note
   */
  void set_note(std::string note) { this->notes.set(note); }

  /**
   * @brief
   *
   * @return double
   */
  virtual double evaluate() {
    fims_distributions::MultinomialLPMF<double> dmultinom;
    // Declare TMBVector in this scope
    dmultinom.observed_values.resize(this->observed_values.size());
    dmultinom.expected_values.resize(this->expected_values.size());
    for (size_t i = 0; i < observed_values.size(); i++) {
      dmultinom.observed_values[i] = this->observed_values[i].initial_value_m;
    }
    for (size_t i = 0; i < expected_values.size(); i++) {
      dmultinom.expected_values[i] = this->expected_values[i].initial_value_m;
    }
    dmultinom.dims.resize(2);
    dmultinom.dims[0] = this->dims[0];
    dmultinom.dims[1] = this->dims[1];
    return dmultinom.evaluate();
  }

  void finalize() {
    if (this->finalized) {
      // log warning that finalize has been called more than once.
      FIMS_WARNING_LOG("DmultinomDistributions  " +
                       fims::to_string(this->id_m) +
                       " has been finalized already.");
    }

    this->finalized = true;  // indicate this has been called already

    std::shared_ptr<fims_info::Information<double>> info =
        fims_info::Information<double>::GetInstance();

    fims_info::Information<double>::density_components_iterator it;

    // search for density component in Information
    it = info->density_components.find(this->id_m);
    // if not found, just return
    if (it == info->density_components.end()) {
      FIMS_WARNING_LOG("DmultinomDistributions " + fims::to_string(this->id_m) +
                       " not found in Information.");
      return;
    } else {
      std::shared_ptr<fims_distributions::MultinomialLPMF<double>> dmultinom =
          std::dynamic_pointer_cast<
              fims_distributions::MultinomialLPMF<double>>(it->second);

      this->lpdf_value = dmultinom->lpdf;

      size_t n_x = dmultinom->lpdf_vec.size();
      this->lpdf_vec = Rcpp::NumericVector(n_x);
      if (this->expected_values.size() != n_x) {
        this->expected_values.resize(n_x);
      }
      if (this->observed_values.size() != n_x) {
        this->observed_values.resize(n_x);
      }
      for (size_t i = 0; i < this->lpdf_vec.size(); i++) {
        this->lpdf_vec[i] = dmultinom->lpdf_vec[i];
        this->expected_values[i].final_value_m = dmultinom->get_expected(i);
        if (dmultinom->input_type != "data") {
          this->observed_values[i].final_value_m = dmultinom->get_observed(i);
        }
      }
      if (dmultinom->input_type == "data") {
        dims.resize(2);
        dims[0] = dmultinom->dims[0];
        dims[1] = dmultinom->dims[1];
        for (size_t i = 0; i < dims[0]; i++) {
          for (size_t j = 0; j < dims[1]; j++) {
            size_t idx = (i * dims[1]) + j;
            this->observed_values[idx].final_value_m = dmultinom->get_observed(
                static_cast<size_t>(i), static_cast<size_t>(j));
          }
        }
      }
    }
  }

  /**
   * @brief Converts the data to json representation for the output.
   * @return A string is returned specifying that the module relates to the
   * distribution interface with a log_normal distribution. It also returns the
   * ID and the natural log of the probability density function values
   * themselves. This string is formatted for a json file.
   */
  virtual std::string to_json() {
    std::stringstream ss;

    ss << "{\n";
    ss << " \"module_name\": \"density\",\n";
    ss << " \"module_id\": " << this->id_m << ",\n";
    ss << " \"module_type\": \"multinomial\",\n";
    ss << "\"observed_data_id\" : " << this->interface_observed_data_id_m
       << ",\n";
    ss << " \"input_type\" : \"" << this->input_type_m << "\",\n";
    ss << " \"density_component\": {\n";
    ss << "  \"lpdf_value\": " << this->lpdf_value << ",\n";
    ss << "  \"value\":[";
    if (this->lpdf_vec.size() == 0) {
      ss << "],\n";
    } else {
      for (size_t i = 0; i < this->lpdf_vec.size() - 1; i++) {
        ss << this->value_to_string(this->lpdf_vec[i]);
        ss << ", ";
      }
      ss << this->value_to_string(this->lpdf_vec[this->lpdf_vec.size() - 1]);

      ss << "],\n";
    }
    ss << "  \"expected_values\":[";
    if (this->expected_values.size() == 0) {
      ss << "],\n";
    } else {
      for (size_t i = 0; i < this->expected_values.size() - 1; i++) {
        ss << this->value_to_string(this->expected_values[i].final_value_m)
           << ", ";
      }
      ss << this->value_to_string(
          this->expected_values[this->expected_values.size() - 1]
              .final_value_m);

      ss << "],\n";
    }
    // no log_sd_values for multinomial
    ss << "  \"observed_values\":[";
    if (this->observed_values.size() == 0) {
      ss << "]\n";
    } else {
      for (size_t i = 0; i < this->observed_values.size() - 1; i++) {
        ss << this->observed_values[i].final_value_m << ", ";
      }
      ss << this->observed_values[this->observed_values.size() - 1]
                .final_value_m
         << "]\n";
    }
    ss << " }}\n";
    return ss.str();
  }

#ifdef TMB_MODEL

  template <typename Type>
  bool add_to_fims_tmb_internal() {
    FIMS_INFO_LOG("Adding multinomial to FIMS.");
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();

    std::shared_ptr<fims_distributions::MultinomialLPMF<Type>> distribution =
        std::make_shared<fims_distributions::MultinomialLPMF<Type>>();

    distribution->id = this->id_m;
    distribution->observed_data_id_m = interface_observed_data_id_m;
    distribution->input_type = this->input_type_m;
    distribution->key.resize(this->key_m->size());
    for (size_t i = 0; i < this->key_m->size(); i++) {
      distribution->key[i] = this->key_m->at(i);
    }
    distribution->observed_values.resize(this->observed_values.size());
    for (size_t i = 0; i < this->observed_values.size(); i++) {
      distribution->observed_values[i] =
          this->observed_values[i].initial_value_m;
    }
    // set relative info
    distribution->expected_values.resize(this->expected_values.size());
    for (size_t i = 0; i < this->expected_values.size(); i++) {
      distribution->expected_values[i] =
          this->expected_values[i].initial_value_m;
    }

    info->density_components[distribution->id] = distribution;
    FIMS_INFO_LOG("Done adding multinomial to FIMS.");
    return true;
  }

  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();

    return true;
  }

#endif
};

#endif

/**
 * @file rcpp_fleet.hpp
 * @brief The Rcpp interface to declare fleets. Allows for the use of
 * methods::new() in R.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_FLEET_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_FLEET_HPP

#include "../../../common/def.hpp"
#include "../../../population_dynamics/fleet/fleet.hpp"
#include "rcpp_interface_base.hpp"

/**
 * @brief Rcpp interface that serves as the parent class for Rcpp fleet
 * interfaces. This type should be inherited and not called from R directly.
 */
class FleetInterfaceBase : public FIMSRcppInterfaceBase {
 public:
  /**
   * @brief The static id of the FleetInterfaceBase object.
   */
  static uint32_t id_g;
  /**
   * @brief The local id of the FleetInterfaceBase object.
   */
  uint32_t id;
  /**
   * @brief The map associating the IDs of FleetInterfaceBase to the objects.
   * This is a live object, which is an object that has been created and lives
   * in memory.
   */
  static std::map<uint32_t, std::shared_ptr<FleetInterfaceBase>> live_objects;

  /**
   * @brief The constructor.
   */
  FleetInterfaceBase() {
    this->id = FleetInterfaceBase::id_g++;
    /* Create instance of map: key is id and value is pointer to
    FleetInterfaceBase */
    // FleetInterfaceBase::live_objects[this->id] = this;
  }

  /**
   * @brief Construct a new Fleet Interface Base object
   *
   * @param other
   */
  FleetInterfaceBase(const FleetInterfaceBase &other) : id(other.id) {}

  /**
   * @brief The destructor.
   */
  virtual ~FleetInterfaceBase() {}

  /**
   * @brief Get the ID for the child fleet interface objects to inherit.
   */
  virtual uint32_t get_id() = 0;
};
// static id of the FleetInterfaceBase object
uint32_t FleetInterfaceBase::id_g = 1;
// local id of the FleetInterfaceBase object map relating the ID of the
// FleetInterfaceBase to the FleetInterfaceBase objects
std::map<uint32_t, std::shared_ptr<FleetInterfaceBase>>
    FleetInterfaceBase::live_objects;
/**
 * @brief The Rcpp interface for Fleet to instantiate from R:
 * fleet <- methods::new(Fleet)
 */
class FleetInterface : public FleetInterfaceBase {
  /**
   * @brief The ID of the observed age-composition data object.
   */
  SharedInt interface_observed_agecomp_data_id_m = -999;
  /**
   * @brief The ID of the observed length-composition data object.
   */
  SharedInt interface_observed_lengthcomp_data_id_m = -999;
  /**
   * @brief The ID of the observed index data object.
   */
  SharedInt interface_observed_index_data_id_m = -999;
  /**
   * @brief The ID of the observed landings data object.
   */
  SharedInt interface_observed_landings_data_id_m = -999;
  /**
   * @brief The ID of the selectivity object.
   */
  SharedInt interface_selectivity_id_m = -999;

 public:
  /**
   * @brief The name of the fleet.
   */
  SharedString name = fims::to_string("NA");
  /**
   * @brief The number of age bins in the fleet data.
   */
  SharedInt n_ages = 0;
  /**
   * @brief The number of length bins in the fleet data.
   */
  SharedInt n_lengths = 0;
  /**
   * @brief The number of years in the fleet data.
   */
  SharedInt n_years = 0;
  /**
   * @brief What units are the observed landings for this fleet measured in.
   * Options are weight or numbers, default is weight.
   */
  SharedString observed_landings_units = fims::to_string("weight");
  /**
   * @brief What units is the observed index of abundance for this fleet
   * measured in. Options are weight or numbers, default is weight.
   */
  SharedString observed_index_units = fims::to_string("weight");
  /**
   * @brief The natural log of the index of abundance scaling parameter
   * for this fleet.
   */
  ParameterVector log_q;
  /**
   * @brief The vector of the natural log of fishing mortality rates for this
   * fleet.
   */
  ParameterVector log_Fmort;
  /**
   * @brief The vector of natural log of the expected total landings for
   * the fleet.
   */
  ParameterVector log_landings_expected;
  /**
   * @brief The vector of natural log of the expected index of abundance
   * for the fleet.
   */
  ParameterVector log_index_expected;
  /**
   * @brief The vector of expected landings-at-age in numbers for the fleet.
   */
  ParameterVector agecomp_expected;
  /**
   * @brief The vector of expected landings-at-length in numbers for the fleet.
   */
  ParameterVector lengthcomp_expected;
  /**
   * @brief The vector of expected landings-at-age in numbers for the fleet.
   */
  ParameterVector agecomp_proportion;
  /**
   * @brief The vector of expected landings-at-length in numbers for the fleet.
   */
  ParameterVector lengthcomp_proportion;
  /**
   * @brief The vector of conversions to go from age to length, i.e., the
   * age-to-length-conversion matrix.
   */
  ParameterVector age_to_length_conversion;

  // derived quantities
  /**
   * @brief Derived landings-at-age in numbers.
   */
  Rcpp::NumericVector derived_landings_naa;
  /**
   * @brief Derived landings-at-length in numbers.
   */
  Rcpp::NumericVector derived_landings_nal;
  /**
   * @brief Derived landings-at-age in weight (mt).
   */
  Rcpp::NumericVector derived_landings_waa;
  /**
   * @brief Derived landings in observed units.
   */
  Rcpp::NumericVector derived_landings_expected;
  /**
   * @brief Derived landings in weight.
   */
  Rcpp::NumericVector derived_landings_w;
  /**
   * @brief Derived landings in numbers.
   */
  Rcpp::NumericVector derived_landings_n;
  /**
   * @brief Derived landings-at-age in numbers.
   */
  Rcpp::NumericVector derived_index_naa;
  /**
   * @brief Derived landings-at-length in numbers.
   */
  Rcpp::NumericVector derived_index_nal;
  /**
   * @brief Derived landings-at-age in weight (mt).
   */
  Rcpp::NumericVector derived_index_waa;
  /**
   * @brief Derived index in observed units.
   */
  Rcpp::NumericVector derived_index_expected;
  /**
   * @brief Derived index in weight.
   */
  Rcpp::NumericVector derived_index_w;
  /**
   * @brief Derived index in numbers.
   */
  Rcpp::NumericVector derived_index_n;
  /**
   * @brief Derived age composition proportions.
   */
  Rcpp::NumericVector derived_agecomp_proportion;
  /**
   * @brief Derived length composition proportions.
   */
  Rcpp::NumericVector derived_lengthcomp_proportion;
  /**
   * @brief Derived age compositions.
   */
  Rcpp::NumericVector derived_agecomp_expected;
  /**
   * @brief Derived length compositions.
   */
  Rcpp::NumericVector derived_lengthcomp_expected;

  /**
   * @brief The constructor.
   */
  FleetInterface() : FleetInterfaceBase() {
    std::shared_ptr<FleetInterface> fleet =
        std::make_shared<FleetInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(fleet);
    /* Create instance of map: key is id and value is pointer to
     FleetInterfaceBase */
    FleetInterfaceBase::live_objects[this->id] = fleet;
  }

  /**
   * @brief Construct a new Fleet Interface object
   *
   * @param other
   */
  FleetInterface(const FleetInterface &other)
      : FleetInterfaceBase(other),
        interface_observed_agecomp_data_id_m(
            other.interface_observed_agecomp_data_id_m),
        interface_observed_lengthcomp_data_id_m(
            other.interface_observed_lengthcomp_data_id_m),
        interface_observed_index_data_id_m(
            other.interface_observed_index_data_id_m),
        interface_observed_landings_data_id_m(
            other.interface_observed_landings_data_id_m),
        interface_selectivity_id_m(other.interface_selectivity_id_m),
        name(other.name),
        n_ages(other.n_ages),
        n_lengths(other.n_lengths),
        n_years(other.n_years),
        observed_landings_units(other.observed_landings_units),
        observed_index_units(other.observed_index_units),
        log_q(other.log_q),
        log_Fmort(other.log_Fmort),
        log_landings_expected(other.log_landings_expected),
        log_index_expected(other.log_index_expected),
        agecomp_expected(other.agecomp_expected),
        lengthcomp_expected(other.lengthcomp_expected),
        agecomp_proportion(other.agecomp_proportion),
        lengthcomp_proportion(other.lengthcomp_proportion),
        age_to_length_conversion(other.age_to_length_conversion),
        derived_landings_naa(other.derived_landings_naa),
        derived_landings_nal(other.derived_landings_nal),
        derived_landings_waa(other.derived_landings_waa),
        derived_landings_expected(other.derived_landings_expected),
        derived_landings_w(other.derived_landings_w),
        derived_landings_n(other.derived_landings_n),
        derived_index_naa(other.derived_index_naa),
        derived_index_nal(other.derived_index_nal),
        derived_index_waa(other.derived_index_waa),
        derived_index_expected(other.derived_index_expected),
        derived_index_w(other.derived_index_w),
        derived_index_n(other.derived_index_n),
        derived_agecomp_proportion(other.derived_agecomp_proportion),
        derived_lengthcomp_proportion(other.derived_lengthcomp_proportion),
        derived_agecomp_expected(other.derived_agecomp_expected),
        derived_lengthcomp_expected(other.derived_lengthcomp_expected) {}

  /**
   * @brief The destructor.
   */
  virtual ~FleetInterface() {}

  /**
   * @brief Gets the ID of the interface base object.
   * @return The ID.
   */
  virtual uint32_t get_id() { return this->id; }

  /**
   * @brief Sets the name of the fleet.
   * @param name The name to set.
   */
  void SetName(const std::string &name) { this->name.set(name); }

  /**
   * @brief Gets the name of the fleet.
   * @return The name.
   */
  std::string GetName() const { return this->name.get(); }

  /**
   * @brief Set the unique ID for the observed age-composition data object.
   * @param observed_agecomp_data_id Unique ID for the observed data object.
   */
  void SetObservedAgeCompDataID(int observed_agecomp_data_id) {
    interface_observed_agecomp_data_id_m.set(observed_agecomp_data_id);
  }

  /**
   * @brief Set the unique ID for the observed length-composition data object.
   * @param observed_lengthcomp_data_id Unique ID for the observed data object.
   */
  void SetObservedLengthCompDataID(int observed_lengthcomp_data_id) {
    interface_observed_lengthcomp_data_id_m.set(observed_lengthcomp_data_id);
  }

  /**
   * @brief Set the unique ID for the observed index data object.
   * @param observed_index_data_id Unique ID for the observed data object.
   */
  void SetObservedIndexDataID(int observed_index_data_id) {
    interface_observed_index_data_id_m.set(observed_index_data_id);
  }

  /**
   * @brief Set the unique ID for the observed landings data object.
   * @param observed_landings_data_id Unique ID for the observed data object.
   */
  void SetObservedLandingsDataID(int observed_landings_data_id) {
    interface_observed_landings_data_id_m.set(observed_landings_data_id);
  }
  /**
   * @brief Set the unique ID for the selectivity object.
   * @param selectivity_id Unique ID for the observed object.
   */
  void SetSelectivityID(int selectivity_id) {
    interface_selectivity_id_m.set(selectivity_id);
  }

  /**
   * @brief Get the unique ID for the selectivity object.
   *
   * @return uint32_t
   */
  uint32_t GetSelectivityID() { return interface_selectivity_id_m.get(); }

  /**
   * @brief Get the unique ID for the observed age-composition data object.
   */
  int GetObservedAgeCompDataID() {
    return interface_observed_agecomp_data_id_m.get();
  }

  /**
   * @brief Get the unique ID for the observed length-composition data
   * object.
   */
  int GetObservedLengthCompDataID() {
    return interface_observed_lengthcomp_data_id_m.get();
  }

  /**
   * @brief Get the unique id for the observed index data object.
   */
  int GetObservedIndexDataID() {
    return interface_observed_index_data_id_m.get();
  }

  /**
   * @brief Get the unique id for the observed landings data object.
   */
  int GetObservedLandingsDataID() {
    return interface_observed_landings_data_id_m.get();
  }
  /**
   * @brief Extracts the derived quantities from `Information` to the Rcpp
   * object.
   */
  virtual void finalize() {
    if (this->finalized) {
      // log warning that finalize has been called more than once.
      FIMS_WARNING_LOG("Fleet " + fims::to_string(this->id) +
                       " has been finalized already.");
    }

    this->finalized = true;  // indicate this has been called already

    std::shared_ptr<fims_info::Information<double>> info =
        fims_info::Information<double>::GetInstance();

    fims_info::Information<double>::fleet_iterator it;

    it = info->fleets.find(this->id);

    if (it == info->fleets.end()) {
      FIMS_WARNING_LOG("Fleet " + fims::to_string(this->id) +
                       " not found in Information.");
      return;
    } else {
      std::shared_ptr<fims_popdy::Fleet<double>> fleet =
          std::dynamic_pointer_cast<fims_popdy::Fleet<double>>(it->second);

      for (size_t i = 0; i < this->log_Fmort.size(); i++) {
        if (this->log_Fmort[i].estimation_type_m.get() == "constant") {
          this->log_Fmort[i].final_value_m = this->log_Fmort[i].initial_value_m;
        } else {
          this->log_Fmort[i].final_value_m = fleet->log_Fmort[i];
        }
      }

      for (size_t i = 0; i < this->log_q.size(); i++) {
        if (this->log_q[i].estimation_type_m.get() == "constant") {
          this->log_q[i].final_value_m = this->log_q[i].initial_value_m;
        } else {
          this->log_q[i].final_value_m = fleet->log_q[i];
        }
      }

      for (size_t i = 0; i < fleet->age_to_length_conversion.size(); i++) {
        if (this->age_to_length_conversion[i].estimation_type_m.get() ==
            "constant") {
          this->age_to_length_conversion[i].final_value_m =
              this->age_to_length_conversion[i].initial_value_m;
        } else {
          this->age_to_length_conversion[i].final_value_m =
              fleet->age_to_length_conversion[i];
        }
      }
    }
  }

#ifdef TMB_MODEL

  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();

    std::shared_ptr<fims_popdy::Fleet<Type>> fleet =
        std::make_shared<fims_popdy::Fleet<Type>>();

    std::stringstream ss;

    // set relative info
    fleet->id = this->id;
    fleet->n_ages = this->n_ages.get();
    fleet->n_lengths = this->n_lengths.get();
    fleet->n_years = this->n_years.get();
    fleet->observed_landings_units = this->observed_landings_units;
    fleet->observed_index_units = this->observed_index_units;

    fleet->fleet_observed_agecomp_data_id_m =
        interface_observed_agecomp_data_id_m.get();

    fleet->fleet_observed_lengthcomp_data_id_m =
        interface_observed_lengthcomp_data_id_m.get();

    fleet->fleet_observed_index_data_id_m =
        interface_observed_index_data_id_m.get();
    fleet->fleet_observed_landings_data_id_m =
        interface_observed_landings_data_id_m.get();

    fleet->fleet_selectivity_id_m = interface_selectivity_id_m.get();

    fleet->log_q.resize(this->log_q.size());
    for (size_t i = 0; i < this->log_q.size(); i++) {
      fleet->log_q[i] = this->log_q[i].initial_value_m;

      if (this->log_q[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Fleet." << this->id << ".log_q." << this->log_q[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(fleet->log_q[i]);
      }
      if (this->log_q[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Fleet." << this->id << ".log_q." << this->log_q[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(fleet->log_q[i]);
      }
    }

    FIMS_INFO_LOG("adding Fleet fmort object to TMB");
    if (this->log_Fmort.size() != static_cast<size_t>(this->n_years.get())) {
      FIMS_ERROR_LOG("The size of `log_Fmort` does not match `n_years`: " +
                     fims::to_string(this->log_Fmort.size()) +
                     " != " + fims::to_string(this->n_years.get()));
      throw std::invalid_argument(
          "Fleet log_Fmort size mismatch."
          "Fleet log_Fmort is of size " +
          fims::to_string(this->log_Fmort.size()) +
          " and the number of years is " +
          fims::to_string(this->n_years.get()));
    }
    fleet->log_Fmort.resize(static_cast<size_t>(this->log_Fmort.size()));
    for (size_t i = 0; i < log_Fmort.size(); i++) {
      fleet->log_Fmort[i] = this->log_Fmort[i].initial_value_m;

      if (this->log_Fmort[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Fleet." << this->id << ".log_Fmort." << this->log_Fmort[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(fleet->log_Fmort[i]);
      }
      if (this->log_Fmort[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Fleet." << this->id << ".log_Fmort." << this->log_Fmort[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(fleet->log_Fmort[i]);
      }
    }
    // add to variable_map
    info->variable_map[this->log_Fmort.id_m] = &(fleet)->log_Fmort;

    if (this->n_lengths.get() > 0) {
      fleet->age_to_length_conversion.resize(
          this->age_to_length_conversion.size());

      if (this->age_to_length_conversion.size() !=
          static_cast<size_t>(this->n_ages.get() * this->n_lengths.get())) {
        FIMS_ERROR_LOG(
            "age_to_length_conversion don't match, " +
            fims::to_string(this->age_to_length_conversion.size()) + " != " +
            fims::to_string((this->n_ages.get() * this->n_lengths.get())));
      }

      for (size_t i = 0; i < fleet->age_to_length_conversion.size(); i++) {
        fleet->age_to_length_conversion[i] =
            this->age_to_length_conversion[i].initial_value_m;
        FIMS_INFO_LOG(" adding Fleet length object to TMB in loop " +
                      fims::to_string(i) + " of " +
                      fims::to_string(fleet->age_to_length_conversion.size()));

        if (this->age_to_length_conversion[i].estimation_type_m.get() ==
            "fixed_effects") {
          ss.str("");
          ss << "Fleet." << this->id << ".age_to_length_conversion."
             << this->age_to_length_conversion[i].id_m;
          info->RegisterParameterName(ss.str());
          info->RegisterParameter(fleet->age_to_length_conversion[i]);
        }
        if (this->age_to_length_conversion[i].estimation_type_m.get() ==
            "random_effects") {
          FIMS_ERROR_LOG(
              "age_to_length_conversion cannot be set to random effects");
        }
      }

      info->variable_map[this->age_to_length_conversion.id_m] =
          &(fleet)->age_to_length_conversion;
    }

    // add to Information
    info->fleets[fleet->id] = fleet;
    FIMS_INFO_LOG("done adding Fleet object to TMB");
    return true;
  }

  /**
   * @brief Adds the parameters to the TMB model.
   * @return A boolean of true.
   */
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();

    return true;
  }

#endif
};

#endif

/**
 * @file rcpp_growth.hpp
 * @brief The Rcpp interface to declare different types of growth, e.g.,
 * empirical weight-at-age data. Allows for the use of methods::new() in R.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_GROWTH_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_GROWTH_HPP

#include "../../../population_dynamics/growth/growth.hpp"
#include "rcpp_interface_base.hpp"

/**
 * @brief Rcpp interface that serves as the parent class for Rcpp growth
 * interfaces. This type should be inherited and not called from R directly.
 */
class GrowthInterfaceBase : public FIMSRcppInterfaceBase {
public:
  /**
   * @brief The static id of the GrowthInterfaceBase object.
   */
  static uint32_t id_g;
  /**
   * @brief The local id of the GrowthInterfaceBase object.
   */
  uint32_t id;
  /**
   * @brief The map associating the IDs of GrowthInterfaceBase to the objects.
   * This is a live object, which is an object that has been created and lives
   * in memory.
   */
  static std::map<uint32_t, std::shared_ptr<GrowthInterfaceBase>> live_objects;

  /**
   * @brief The constructor.
   */
  GrowthInterfaceBase() {
    this->id = GrowthInterfaceBase::id_g++;
    /* Create instance of map: key is id and value is pointer to
    GrowthInterfaceBase */
    // GrowthInterfaceBase::live_objects[this->id] =
    // std::make_shared<GrowthInterfaceBase>(*this);
  }

  /**
   * @brief Construct a new Growth Interface Base object
   *
   * @param other
   */
  GrowthInterfaceBase(const GrowthInterfaceBase &other) : id(other.id) {}

  /**
   * @brief The destructor.
   */
  virtual ~GrowthInterfaceBase() {}

  /**
   * @brief Get the ID for the child growth interface objects to inherit.
   */
  virtual uint32_t get_id() = 0;

  /**
   * @brief A method for each child growth interface object to inherit so
   * each growth option can have an evaluate() function.
   */
  virtual double evaluate(double age) = 0;
};
// static id of the GrowthInterfaceBase object
uint32_t GrowthInterfaceBase::id_g = 1;
// local id of the GrowthInterfaceBase object map relating the ID of the
// GrowthInterfaceBase to the GrowthInterfaceBase objects
std::map<uint32_t, std::shared_ptr<GrowthInterfaceBase>>
    GrowthInterfaceBase::live_objects;

/**
 * @brief Rcpp interface for EWAAGrowth to instantiate the object from R:
 * ewaa <- methods::new(EWAAGrowth). Where, EWAA stands for empirical weight at
 * age and growth is not actually estimated.
 */
class EWAAGrowthInterface : public GrowthInterfaceBase {
public:
  /**
   * @brief Weights (mt) for each age class.
   */
  RealVector weights;
  /**
   * @brief Ages (years) for each age class.
   */
  RealVector ages;
  /**
   * @brief An integer specifying the number of years.
   *
   */
  SharedInt n_years;
  /**
   * @brief A map of empirical weight-at-age values allowing multiple modules to
   * access and modify the weights without copying values between modules.
   */
  std::shared_ptr<std::map<int, std::map<double, double>>> ewaa;
  /**
   * @brief Have weight and age vectors been set? The default is false.
   */
  bool initialized = false;

  /**
   * @brief The constructor.
   */
  EWAAGrowthInterface() : GrowthInterfaceBase() {
    this->ewaa = std::make_shared<std::map<int, std::map<double, double>>>();
    GrowthInterfaceBase::live_objects[this->id] =
        std::make_shared<EWAAGrowthInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        std::make_shared<EWAAGrowthInterface>(*this));
  }

  /**
   * @brief Construct a new EWAAGrowthInterface object
   *
   * @param other
   */
  EWAAGrowthInterface(const EWAAGrowthInterface &other)
      : GrowthInterfaceBase(other), weights(other.weights), ages(other.ages),
        n_years(other.n_years), ewaa(other.ewaa),
        initialized(other.initialized) {}

  /**
   * @brief The destructor.
   */
  virtual ~EWAAGrowthInterface() {}

  /**
   * @brief Gets the ID of the interface base object.
   * @return The ID.
   */
  virtual uint32_t get_id() { return this->id; }

  /**
   * @brief Create a map of input numeric vectors.
   * @param weights Type vector of weights.
   * @param ages Type vector of ages.
   * @param n_years An integer specifying the number of years.
   * @return std::map<T, T>.
   */
  inline std::map<int, std::map<double, double>> make_map(RealVector ages, RealVector weights,
                                           SharedInt n_years) {
    std::map<int, std::map<double, double>> mymap;
    const size_t n_years_plus_one = static_cast<size_t>(n_years.get() + 1);
    
    // Reject invalid year counts because map keys are expected to include
    // at least one model year.
    if (n_years.get() < 1) {
      Rcpp::stop("EWAA Error:: n_years must be at least 1");
    }

    // Reject empty vectors because we need at least one age-weight pair.
    if (weights.size() == 0 || ages.size() == 0) {
      Rcpp::stop("EWAA Error:: ages and weights must have at least one value");
    }

    // Accept either:
    // 1) one weight vector by age (shared across years), or
    // 2) a full year-by-age matrix flattened as (n_years + 1) * n_ages.
    if ((weights.size() != ages.size() * n_years_plus_one) &&
       (weights.size() != ages.size())) {
      Rcpp::stop("weights size does not match ages size or ages size times "
                 "(n_years + 1), where the plus one is for the beginning "
                 "of the year after the terminal year spawning-biomass "
                 "calculations.");
    } else if (weights.size() == ages.size()) {
      // One age-specific vector was provided, so replicate the same
      // weight-at-age values for every year key (0 through n_years).
      for (size_t y = 0; y < n_years_plus_one; y++) {
        for (size_t i = 0; i < ages.size(); i++) {
          mymap[y][ages[i]] = weights[i];
        }
      }
    } else if (weights.size() == ages.size() * n_years_plus_one) {
      // A flattened year-by-age matrix was provided, so map each block of
      // n_ages values to the corresponding year key (0 through n_years).
      for (size_t y = 0; y < n_years_plus_one; y++) {
        for (size_t i = 0; i < ages.size(); i++) {
          mymap[y][ages[i]] = weights[y * ages.size() + i];
        }
      }
    }
    return mymap;
  }

    /**
     * @brief Evaluate the growth using empirical weight at age.
     * @param age The age at of the individual to evaluate weight.
     * @details This can be called from R using ewaagrowth.evaluate(age).
     */
    virtual double evaluate(double age) {
      fims_popdy::EWAAGrowth<double> EWAAGrowth;

      // Build the EWAA map once from R inputs the first time evaluate() is
      // called.
      if (initialized == false) {
        EWAAGrowth.ewaa = make_map(this->ages, this->weights, this->n_years);
        initialized = true;
      } else {
        // Prevent re-initializing this object with a second evaluate() call.
        Rcpp::stop(
            "this empirical weight at age object is already initialized");
      }
      return EWAAGrowth.evaluate(0, age);
    }

    /**
     * @brief Converts the data to json representation for the output.
     * @return A string is returned specifying that the module relates to the
     * growth interface with empirical weight at age. It also returns the ID,
     * the rank of 1, the dimensions, age bins, and the calculated values
     * themselves. This string is formatted for a json file.
     */
    virtual std::string to_json() {
      std::stringstream ss;
      ss << "{\n";
      ss << " \"module_name\": \"Growth\",\n";
      ss << " \"module_type\": \"EWAA\",\n";
      ss << " \"module_id\":" << this->id << ",\n";
      ss << " \"parameters\": [\n{\n";
      ss << " \"name\": \"weight_at_age\",\n";
      ss << " \"id\": null,\n";
      ss << " \"type\": \"vector\",\n";
      ss << " \"dimensionality\": {\n";
      ss << "  \"header\": [\"n_years+1\",\"n_ages\"],\n";
      ss << "  \"dimensions\": [" << this->n_years.get() + 1 << "," << this->ages.size() << "]\n},\n";

      ss << " \"values\": [\n";
      for (size_t i = 0; i < weights.size() - 1; i++) {
        ss << "{\n";
        ss << "\"id\": null,\n";
        ss << "\"value\": " << weights[i] << ",\n";
        ss << "\"estimated_value\": " << weights[i] << ",\n";
        ss << "\"estimation_type\": \"constant\"\n";
        ss << "},\n";
      }
      ss << "{\n";
      ss << "\"id\": null,\n";
      ss << "\"value\": " << weights[weights.size() - 1] << ",\n";
      ss << "\"estimated_value\": " << weights[weights.size() - 1] << ",\n";
      ss << "\"estimation_type\": \"constant\"\n";
      ss << "}\n]\n";
      ss << "}\n]\n}\n";
      return ss.str();
    }

#ifdef TMB_MODEL

    template <typename Type> bool add_to_fims_tmb_internal() {
      std::shared_ptr<fims_info::Information<Type>> info =
          fims_info::Information<Type>::GetInstance();

      std::shared_ptr<fims_popdy::EWAAGrowth<Type>> ewaa_growth =
          std::make_shared<fims_popdy::EWAAGrowth<Type>>();

      // set relative info
      ewaa_growth->id = this->id;
      ewaa_growth->ewaa =
          make_map(this->ages, this->weights, this->n_years); // this->ewaa;
      // add to Information
      info->growth_models[ewaa_growth->id] = ewaa_growth;

      return true;
    }

  /**
   * @brief Adds the parameters to the TMB model.
   * @return A boolean of true.
   */
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();

      return true;
    }

#endif
  };

#endif

/**
 * @file rcpp_interface_base.hpp
 * @brief The Rcpp interface to declare objects that are used ubiquitously
 * throughout the Rcpp interface, e.g., Parameters and ParameterVectors.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_INTERFACE_BASE_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_INTERFACE_BASE_HPP

#include <RcppCommon.h>
#include <map>
#include <vector>

#include "../../../common/def.hpp"
#include "../../../common/information.hpp"
#include "../../interface.hpp"
#include "rcpp_shared_primitive.hpp"
#include <limits>

#define RCPP_NO_SUGAR
#include <Rcpp.h>

/**
 * @brief An Rcpp interface that defines the Parameter class.
 *
 * @details An Rcpp interface class that defines the interface between R and
 * C++ for a parameter type.
 */
class Parameter {
 public:
  /**
   * @brief The static ID of the Parameter object.
   */
  static uint32_t id_g;
  /**
   * @brief The local ID of the Parameter object.
   */
  uint32_t id_m;
  /**
   * @brief The initial value of the parameter.
   */
  double initial_value_m = 0.0;
  /**
   * @brief The final value of the parameter.
   */
  double final_value_m = 0.0;
  /**
   * @brief A string indicating the estimation type. Options are: constant,
   * fixed_effects, or random_effects, where the default is constant.
   */
  SharedString estimation_type_m = SharedString("constant");

  /**
   * @brief The constructor for initializing a parameter.
   */
  Parameter(double value, std::string estimation_type)
      : id_m(Parameter::id_g++),
        initial_value_m(value),
        estimation_type_m(estimation_type) {}

  /**
   * @brief The constructor for initializing a parameter.
   */
  Parameter(const Parameter& other)
      : id_m(other.id_m),
        initial_value_m(other.initial_value_m),
        final_value_m(other.final_value_m),
        estimation_type_m(other.estimation_type_m) {}

  /**
   * @brief The constructor for initializing a parameter.
   */
  Parameter& operator=(const Parameter& right) {
    // Check for self-assignment!
    if (this == &right)  // Same object?
      return *this;      // Yes, so skip assignment, and just return *this.
    this->id_m = right.id_m;
    this->initial_value_m = right.initial_value_m;
    this->estimation_type_m = right.estimation_type_m;
    return *this;
  }

  /**
   * @brief The constructor for initializing a parameter.
   */
  Parameter(double value) {
    initial_value_m = value;
    id_m = Parameter::id_g++;
  }

  /**
   * @brief The constructor for initializing a parameter.
   * @details Set value to 0 when there is no input value.
   */
  Parameter() {
    initial_value_m = 0;
    id_m = Parameter::id_g++;
  }
};
/**
 * @brief The unique ID for the variable map that points to a fims::Vector.
 */
uint32_t Parameter::id_g = 0;

/**
 * @brief Sanitize a double value by replacing NaN or Inf with -999.0.
 *
 * @param x The input double value.
 * @return The sanitized double value.
 */
inline double sanitize_val(double x) {
  if (std::isnan(x) || std::isinf(x)) {
    return -999.0;
  }
  return x;
}

/**
 * @brief Output for std::ostream& for a parameter.
 *
 * @param out The stream.
 * @param p A parameter.
 * @return std::ostream&
 */
std::ostream& operator<<(std::ostream& out, const Parameter& p) {
  out << "{\"id\": " << p.id_m
      << ",\n\"value\": " << sanitize_val(p.initial_value_m)
      << ",\n\"estimated_value\": " << sanitize_val(p.final_value_m);
  out << ",\n\"estimation_type\": \"" << p.estimation_type_m << "\"\n}";

  return out;
}

/**
 * @brief An Rcpp interface class that defines the ParameterVector class.
 *
 * @details An Rcpp interface class that defines the interface between R and
 * C++ for a parameter vector type.
 */
class ParameterVector {
 public:
  /**
   * @brief The static ID of the Parameter object.
   */
  static uint32_t id_g;
  /**
   * @brief Parameter storage.
   */
  std::shared_ptr<std::vector<Parameter>> storage_m;
  /**
   * @brief The local ID of the Parameter object.
   */
  uint32_t id_m;

  /**
   * @brief The constructor.
   */
  ParameterVector() {
    this->id_m = ParameterVector::id_g++;
    this->storage_m = std::make_shared<std::vector<Parameter>>();
    this->storage_m->resize(1);  // push_back(Rcpp::wrap(p));
  }

  /**
   * @brief The constructor.
   */
  ParameterVector(const ParameterVector& other)
      : storage_m(other.storage_m), id_m(other.id_m) {}

  /**
   * @brief The constructor.
   */
  ParameterVector(size_t size) {
    this->id_m = ParameterVector::id_g++;
    this->storage_m = std::make_shared<std::vector<Parameter>>();
    this->storage_m->resize(size);
    for (size_t i = 0; i < size; i++) {
      storage_m->at(i) = Parameter();
    }
  }

  /**
   * @brief The constructor for initializing a parameter vector.
   * @param x A numeric vector.
   * @param size The number of elements to copy over.
   */
  ParameterVector(Rcpp::NumericVector x, size_t size) {
    if (static_cast<size_t>(x.size()) != size) {
      throw std::invalid_argument(
          "Error in call to ParameterVector(Rcpp::NumericVector x, size_t "
          "size): x.size() != size argument.");
    } else {
      this->id_m = ParameterVector::id_g++;
      this->storage_m = std::make_shared<std::vector<Parameter>>();
      // Use std::min to avoid comparing signed and unsigned types
      size_t n = std::min(static_cast<size_t>(x.size()), size);
      this->storage_m->resize(n);
      for (size_t i = 0; i < n; i++) {
        storage_m->at(i).initial_value_m = x[i];
      }
    }
  }

  /**
   * @brief The constructor for initializing a parameter vector.
   * @param v A vector of doubles.
   */
  ParameterVector(const fims::Vector<double>& v) {
    this->id_m = ParameterVector::id_g++;
    this->storage_m = std::make_shared<std::vector<Parameter>>();
    this->storage_m->resize(v.size());
    for (size_t i = 0; i < v.size(); i++) {
      storage_m->at(i).initial_value_m = v[i];
    }
  }

  /**
   * @brief Destroy the Parameter Vector object.
   *
   */
  virtual ~ParameterVector() {}

  /**
   * @brief Gets the ID of the ParameterVector object.
   */
  virtual uint32_t get_id() { return this->id_m; }

  /**
   * @brief The accessor where the first index starts is zero.
   * @param pos The position of the ParameterVector that you want returned.
   */
  inline Parameter& operator[](size_t pos) { return this->storage_m->at(pos); }

  /**
   * @brief The accessor where the first index starts at one. This function is
   * for calling accessing from R.
   * @param pos The position of the ParameterVector that you want returned.
   */
  SEXP at(R_xlen_t pos) {
    if (static_cast<size_t>(pos) == 0 ||
        static_cast<size_t>(pos) > this->storage_m->size()) {
      throw std::invalid_argument("ParameterVector: Index out of range");
      FIMS_ERROR_LOG(fims::to_string(pos) + "!<" +
                     fims::to_string(this->size()));
      return NULL;
    }
    return Rcpp::wrap(this->storage_m->at(pos - 1));
  }

  /**
   * @brief An internal accessor for calling a position of a ParameterVector
   * from R.
   * @param pos An integer specifying the position of the ParameterVector
   * you want returned. The first position is one and the last position is
   * the same as the size of the ParameterVector.
   */
  Parameter& get(size_t pos) {
    if (pos >= this->storage_m->size()) {
      throw std::invalid_argument("ParameterVector: Index out of range");
    }
    return (this->storage_m->at(pos));
  }

  /**
   * @brief An internal setter for setting a position of a ParameterVector
   * from R.
   * @param pos An integer specifying the position of the ParameterVector
   * you want to set. The first position is one and the last position is the
   * same as the size of the ParameterVector.
   * @param p A numeric value specifying the value to set position `pos` to
   * in the ParameterVector.
   */
  void set(size_t pos, const Parameter& p) { this->storage_m->at(pos) = p; }

  /**
   * @brief Returns the size of a ParameterVector.
   */
  size_t size() { return this->storage_m->size(); }

  /**
   * @brief Resizes a ParameterVector to the desired length.
   * @param size An integer specifying the desired length for the
   * ParameterVector to be resized to.
   */
  void resize(size_t size) { this->storage_m->resize(size); }

  /**
   * @brief Sets all Parameters within a ParameterVector as estimable.
   *
   * @param estimable A boolean specifying if all Parameters within the
   * ParameterVector should be estimated within the model. A value of true
   * leads to all Parameters being estimated.
   */
  void set_all_estimable(bool estimable) {
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      if (estimable) {
        this->storage_m->at(i).estimation_type_m.set("fixed_effects");
      } else {
        this->storage_m->at(i).estimation_type_m.set("constant");
      }
    }
  }

  /**
   * @brief Sets all Parameters within a ParameterVector as random effects.
   *
   * @param random A boolean specifying if all Parameters within the
   * ParameterVector should be designated as random effects. A value of true
   * leads to all Parameters being random effects.
   */
  void set_all_random(bool random) {
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      if (random) {
        this->storage_m->at(i).estimation_type_m.set("random_effects");
      } else {
        this->storage_m->at(i).estimation_type_m.set("constant");
      }
    }
  }

  /**
   * @brief Sets the value of all Parameters in the ParameterVector to the
   * provided value.
   *
   * @param value A double specifying the value to set all Parameters to
   * within the ParameterVector.
   */
  void fill(double value) {
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      storage_m->at(i).initial_value_m = value;
    }
  }

  /**
   * @brief The printing methods for a ParameterVector.
   *
   */
  void show() {
    Rcpp::Rcout << this->storage_m->data() << "\n";

    for (size_t i = 0; i < this->storage_m->size(); i++) {
      Rcpp::Rcout << storage_m->at(i) << "  ";
    }
  }
};
uint32_t ParameterVector::id_g = 0;

/**
 * @brief Output for std::ostream& for a ParameterVector.
 *
 * @param out The stream.
 * @param v A ParameterVector.
 * @return std::ostream&
 */
std::ostream& operator<<(std::ostream& out, ParameterVector& v) {
  out << "[";
  size_t size = v.size();
  for (size_t i = 0; i < size - 1; i++) {
    out << v[i] << ", ";
  }
  out << v[size - 1] << "]";
  return out;
}

/**
 * @brief An Rcpp interface class that defines the RealVector class.
 *
 * @details An Rcpp interface class that defines the interface between R and
 * C++ for a real vector type. Underlying values are held in a shared pointer
 * and are carried over to any copies of this vector.
 */
class RealVector {
 public:
  /**
   * @brief The static ID of the RealVector object.
   */
  static uint32_t id_g;
  /**
   * @brief real storage.
   */
  std::shared_ptr<std::vector<double>> storage_m;
  /**
   * @brief The local ID of the RealVector object.
   */
  uint32_t id_m;

  /**
   * @brief The constructor.
   */
  RealVector() {
    this->id_m = RealVector::id_g++;
    this->storage_m = std::make_shared<std::vector<double>>();
    this->storage_m->resize(1);
  }

  /**
   * @brief The constructor.
   */
  RealVector(const RealVector& other)
      : storage_m(other.storage_m), id_m(other.id_m) {}

  /**
   * @brief The constructor.
   */
  RealVector(size_t size) {
    this->id_m = RealVector::id_g++;
    this->storage_m = std::make_shared<std::vector<double>>();
    this->storage_m->resize(size);
  }

  /**
   * @brief The constructor for initializing a real vector.
   * @param x A numeric vector.
   * @param size The number of elements to copy over.
   */
  RealVector(Rcpp::NumericVector x, size_t size) {
    this->id_m = RealVector::id_g++;
    this->storage_m = std::make_shared<std::vector<double>>();
    this->storage_m->assign(x.begin(), x.end());
  }

  /**
   * @brief The constructor for initializing a real vector.
   * @param v A vector of doubles.
   */
  RealVector(const fims::Vector<double>& v) {
    this->id_m = RealVector::id_g++;
    this->storage_m = std::make_shared<std::vector<double>>();
    this->storage_m->resize(v.size());
    for (size_t i = 0; i < v.size(); i++) {
      storage_m->at(i) = v[i];
    }
  }

  /**
   * @brief Destroy the real Vector object.
   *
   */
  virtual ~RealVector() {}

  /**
   * @brief
   *
   * @param v
   * @return RealVector&
   */
  RealVector& operator=(const Rcpp::NumericVector& v) {
    this->storage_m->assign(v.begin(), v.end());
    return *this;
  }

  /**
   * @brief Gets the ID of the RealVector object.
   */
  virtual uint32_t get_id() { return this->id_m; }

  /**
   * @brief
   *
   * @param orig
   */
  void fromRVector(const Rcpp::NumericVector& orig) {
    this->storage_m->resize(orig.size());
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      this->storage_m->at(i) = orig[i];
    }
  }

  /**
   * @brief
   *
   * @return Rcpp::NumericVector
   */
  Rcpp::NumericVector toRVector() {
    Rcpp::NumericVector ret(this->storage_m->size());
    for (size_t i = 0; i < this->size(); i++) {
      ret[i] = this->storage_m->at(i);
    }

    return ret;
  }

  /**
   * @brief The accessor where the first index starts is zero.
   * @param pos The position of the RealVector that you want returned.
   */
  inline double& operator[](size_t pos) { return this->storage_m->at(pos); }

  /**
   * @brief The accessor where the first index starts at one. This function is
   * for calling accessing from R.
   * @param pos The position of the ParameterVector that you want returned.
   */
  SEXP at(R_xlen_t pos) {
    if (static_cast<size_t>(pos) == 0 ||
        static_cast<size_t>(pos) > this->storage_m->size()) {
      throw std::invalid_argument("RealVector: Index out of range");
      FIMS_ERROR_LOG(fims::to_string(pos) + "!<" +
                     fims::to_string(this->size()));
      return NULL;
    }
    return Rcpp::wrap(this->storage_m->at(pos - 1));
  }

  /**
   * @brief An internal accessor for calling a position of a RealVector
   * from R.
   * @param pos An integer specifying the position of the RealVector
   * you want returned. The first position is one and the last position is
   * the same as the size of the RealVector.
   */
  double& get(size_t pos) {
    if (pos >= this->storage_m->size()) {
      throw std::invalid_argument("RealVector: Index out of range");
    }
    return (this->storage_m->at(pos));
  }

  /**
   * @brief An internal setter for setting a position of a RealVector
   * from R.
   * @param pos An integer specifying the position of the RealVector
   * you want to set. The first position is one and the last position is the
   * same as the size of the RealVector.
   * @param p A numeric value specifying the value to set position `pos` to
   * in the RealVector.
   */
  void set(size_t pos, const double& p) { this->storage_m->at(pos) = p; }

  /**
   * @brief Returns the size of a RealVector.
   */
  size_t size() { return this->storage_m->size(); }

  /**
   * @brief Resizes a RealVector to the desired length.
   * @param size An integer specifying the desired length for the
   * RealVector to be resized to.
   */
  void resize(size_t size) { this->storage_m->resize(size); }

  /**
   * @brief Sets the value of all elements in the RealVector to the
   * provided value.
   *
   * @param value A double specifying the value to set all elements to
   * within the RealVector.
   */
  void fill(double value) {
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      storage_m->at(i) = value;
    }
  }

  /**
   * @brief The printing methods for a RealVector.
   *
   */
  void show() {
    Rcpp::Rcout << this->storage_m->data() << "\n";

    for (size_t i = 0; i < this->storage_m->size(); i++) {
      Rcpp::Rcout << storage_m->at(i) << "  ";
    }
  }
};
uint32_t RealVector::id_g = 0;

/**
 *@brief Base class for all interface objects.
 */
class FIMSRcppInterfaceBase {
 public:
  /**
   * @brief Is the object already finalized? The default is false.
   */
  bool finalized = false;
  /**
   * @brief FIMS interface object vectors.
   */
  static std::vector<std::shared_ptr<FIMSRcppInterfaceBase>>
      fims_interface_objects;

  /**
   * @brief A virtual method to inherit to add objects to the TMB model.
   */
  virtual bool add_to_fims_tmb() {
    Rcpp::Rcout << "fims_rcpp_interface_base::add_to_fims_tmb(): Not yet "
                   "implemented.\n";
    return false;
  }

  /**
   * @brief Extracts derived quantities back to the Rcpp interface object from
   * the Information object.
   */
  virtual void finalize() {}

  /**
   * @brief Convert the data to json representation for the output.
   */
  virtual std::string to_json() {
    FIMS_WARNING_LOG("Method not yet defined.");
    return "{\"name\": \"not yet implemented\"}";
  }

  /**
   * @brief Report the parameter value as a string.
   *
   * @param value
   * @return std::string
   */
  std::string value_to_string(double value) {
    std::stringstream ss;
    if (value == std::numeric_limits<double>::infinity()) {
      ss << "\"Infinity\"";
    } else if (value == -std::numeric_limits<double>::infinity()) {
      ss << "\"-Infinity\"";
    } else if (value != value) {
      ss << "-999";
    } else {
      // Set precision (R default is 16)
      ss << std::fixed << std::setprecision(16) << value;
    }
    return ss.str();
  }
  /**
   * @brief Make a string of dimensions for the model.
   */
  std::string make_dimensions(uint32_t start, uint32_t end, uint32_t rep = 1) {
    std::stringstream ss;

    for (size_t i = 0; i < rep; i++) {
      for (size_t j = start; j < end; j++) {
        ss << j << ", ";
      }
      if (i < (rep - 1)) {
        ss << end << ", ";
      } else {
        ss << end;
      }
    }
    return ss.str();
  }
};
std::vector<std::shared_ptr<FIMSRcppInterfaceBase>>
    FIMSRcppInterfaceBase::fims_interface_objects;

#endif

/**
 * @file rcpp_math.hpp
 * @brief The Rcpp interface to declare different mathematical functions that
 * are written in C++ but can be used within R.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_MATH_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_MATH_HPP

#include "rcpp_interface_base.hpp"
#include "../../../common/fims_math.hpp"

/**
 * @brief A rcpp interface to the logit function.
 *
 * @param a Lower bound of the logit function, typically 0.0.
 * @param b Upper bound of the logit function, typically 1.0.
 * @param x A single numeric value (double) to be transformed on the real line.
 * @return A double in real space rather than the bounded space.
 */
double logit_rcpp(double a, double b, double x) {
  return fims_math::logit<double>(a, b, x);
}

/**
 * @brief A rcpp interface to the inverse-logit function.
 *
 * @param a Lower bound of the logit function, typically 0.0.
 * @param b Upper bound of the logit function, typically 1.0.
 * @param logit_x A single numeric value (double) in real space.
 * @return A double in the bounded space rather than real space.
 */
double inv_logit_rcpp(double a, double b, double logit_x) {
  return fims_math::inv_logit<double>(a, b, logit_x);
}

#endif

/**
 * @file rcpp_maturity.hpp
 * @brief The Rcpp interface to declare different maturity options, e.g.,
 * logistic. Allows for the use of methods::new() in R.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_MATURITY_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_MATURITY_HPP

#include "../../../population_dynamics/maturity/maturity.hpp"
#include "rcpp_interface_base.hpp"

/**
 * @brief Rcpp interface that serves as the parent class for Rcpp maturity
 * interfaces. This type should be inherited and not called from R directly.
 */
class MaturityInterfaceBase : public FIMSRcppInterfaceBase {
 public:
  /**
   * @brief The static id of the MaturityInterfaceBase object.
   */
  static uint32_t id_g;
  /**
   * @brief The local id of the MaturityInterfaceBase object.
   */
  uint32_t id;
  /**
   * @brief The map associating the IDs of MaturityInterfaceBase to the objects.
   * This is a live object, which is an object that has been created and lives
   * in memory.
   */
  static std::map<uint32_t, std::shared_ptr<MaturityInterfaceBase>>
      live_objects;

  /**
   * @brief The constructor.
   */
  MaturityInterfaceBase() {
    this->id = MaturityInterfaceBase::id_g++;
    /* Create instance of map: key is id and value is pointer to
    MaturityInterfaceBase */
    // MaturityInterfaceBase::live_objects[this->id] = this;
  }

  /**
   * @brief Construct a new Maturity Interface Base object
   *
   * @param other
   */
  MaturityInterfaceBase(const MaturityInterfaceBase& other) : id(other.id) {}

  /**
   * @brief The destructor.
   */
  virtual ~MaturityInterfaceBase() {}

  /**
   * @brief Get the ID for the child maturity interface objects to inherit.
   */
  virtual uint32_t get_id() = 0;

  /**
   * @brief A method for each child maturity interface object to inherit so
   * each maturity option can have an evaluate() function.
   */
  virtual double evaluate(double x) = 0;
};
// static id of the MaturityInterfaceBase object
uint32_t MaturityInterfaceBase::id_g = 1;
// local id of the MaturityInterfaceBase object map relating the ID of the
// MaturityInterfaceBase to the MaturityInterfaceBase objects
std::map<uint32_t, std::shared_ptr<MaturityInterfaceBase>>
    MaturityInterfaceBase::live_objects;

/**
 * @brief Rcpp interface for logistic maturity to instantiate the object from R:
 * logistic_maturity <- methods::new(logistic_maturity).
 */
class LogisticMaturityInterface : public MaturityInterfaceBase {
 public:
  /**
   * @brief The index value at which the response reaches 0.5.
   */
  ParameterVector inflection_point;
  /**
   * @brief The width of the curve at the inflection point.
   */
  ParameterVector slope;

  /**
   * @brief The constructor.
   */
  LogisticMaturityInterface() : MaturityInterfaceBase() {
    MaturityInterfaceBase::live_objects[this->id] =
        std::make_shared<LogisticMaturityInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        MaturityInterfaceBase::live_objects[this->id]);
  }

  /**
   * @brief Construct a new Logistic Maturity Interface object
   *
   * @param other
   */
  LogisticMaturityInterface(const LogisticMaturityInterface& other)
      : MaturityInterfaceBase(other),
        inflection_point(other.inflection_point),
        slope(other.slope) {}

  /**
   * @brief The destructor.
   */
  virtual ~LogisticMaturityInterface() {}

  /**
   * @brief Gets the ID of the interface base object.
   * @return The ID.
   */
  virtual uint32_t get_id() { return this->id; }

  /**
   * @brief Evaluate maturity using the logistic function.
   * @param x The independent variable in the logistic function (e.g., age or
   * size in maturity).
   */
  virtual double evaluate(double x) {
    fims_popdy::LogisticMaturity<double> LogisticMat;
    LogisticMat.inflection_point.resize(1);
    LogisticMat.inflection_point[0] = this->inflection_point[0].initial_value_m;
    LogisticMat.slope.resize(1);
    LogisticMat.slope[0] = this->slope[0].initial_value_m;
    return LogisticMat.evaluate(x);
  }

  /**
   * @brief Extracts derived quantities back to the Rcpp interface object from
   * the Information object.
   */
  virtual void finalize() {
    if (this->finalized) {
      // log warning that finalize has been called more than once.
      FIMS_WARNING_LOG("Logistic Maturity  " + fims::to_string(this->id) +
                       " has been finalized already.");
    }

    this->finalized = true;  // indicate this has been called already

    std::shared_ptr<fims_info::Information<double>> info =
        fims_info::Information<double>::GetInstance();

    fims_info::Information<double>::maturity_models_iterator it;

    // search for maturity in Information
    it = info->maturity_models.find(this->id);
    // if not found, just return
    if (it == info->maturity_models.end()) {
      FIMS_WARNING_LOG("Logistic Maturity " + fims::to_string(this->id) +
                       " not found in Information.");
      return;
    } else {
      std::shared_ptr<fims_popdy::LogisticMaturity<double>> mat =
          std::dynamic_pointer_cast<fims_popdy::LogisticMaturity<double>>(
              it->second);

      for (size_t i = 0; i < inflection_point.size(); i++) {
        if (this->inflection_point[i].estimation_type_m.get() == "constant") {
          this->inflection_point[i].final_value_m =
              this->inflection_point[i].initial_value_m;
        } else {
          this->inflection_point[i].final_value_m = mat->inflection_point[i];
        }
      }

      for (size_t i = 0; i < slope.size(); i++) {
        if (this->slope[i].estimation_type_m.get() == "constant") {
          this->slope[i].final_value_m = this->slope[i].initial_value_m;
        } else {
          this->slope[i].final_value_m = mat->slope[i];
        }
      }
    }
  }

  /**
   * @brief Converts the data to json representation for the output.
   * @return A string is returned specifying that the module relates to the
   * maturity interface with logistic maturity. It also returns the ID and the
   * parameters. This string is formatted for a json file.
   */
  virtual std::string to_json() {
    std::stringstream ss;
    ss << "{\n";
    ss << " \"module_name\": \"Maturity\",\n";
    ss << " \"module_type\": \"Logistic\",\n";
    ss << " \"module_id\": " << this->id << ",\n";

    ss << " \"parameters\": [\n{\n";
    ss << "   \"name\": \"inflection_point\",\n";
    ss << "   \"id\":" << this->inflection_point.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [1]\n},\n";
    ss << "   \"values\":" << this->inflection_point << "},\n ";

    ss << "{\n";
    ss << "   \"name\": \"slope\",\n";
    ss << "   \"id\":" << this->slope.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [1]\n},\n";
    ss << "   \"values\":" << this->slope << "}]\n";

    ss << "}";

    return ss.str();
  }

#ifdef TMB_MODEL

  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();

    std::shared_ptr<fims_popdy::LogisticMaturity<Type>> maturity =
        std::make_shared<fims_popdy::LogisticMaturity<Type>>();

    // set relative info
    maturity->id = this->id;
    std::stringstream ss;
    maturity->inflection_point.resize(this->inflection_point.size());
    for (size_t i = 0; i < this->inflection_point.size(); i++) {
      maturity->inflection_point[i] = this->inflection_point[i].initial_value_m;
      if (this->inflection_point[i].estimation_type_m.get() ==
          "fixed_effects") {
        ss.str("");
        ss << "Maturity." << this->id << ".inflection_point."
           << this->inflection_point[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(maturity->inflection_point[i]);
      }
      if (this->inflection_point[i].estimation_type_m.get() ==
          "random_effects") {
        ss.str("");
        ss << "Maturity." << this->id << ".inflection_point."
           << this->inflection_point[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(maturity->inflection_point[i]);
      }
    }

    maturity->slope.resize(this->slope.size());
    for (size_t i = 0; i < this->slope.size(); i++) {
      maturity->slope[i] = this->slope[i].initial_value_m;
      if (this->slope[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Maturity." << this->id << ".slope." << this->slope[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(maturity->slope[i]);
      }
      if (this->slope[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Maturity." << this->id << ".slope." << this->slope[i].id_m;
        info->RegisterRandomEffect(maturity->slope[i]);
        info->RegisterRandomEffectName(ss.str());
      }
    }

    // add to Information
    info->maturity_models[maturity->id] = maturity;

    return true;
  }

  /**
   * @brief Adds the parameters to the TMB model.
   * @return A boolean of true.
   */
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();

    return true;
  }

#endif
};

#endif

/**
 * @file rcpp_models.hpp
 * @brief The Rcpp interface to declare different types of models. Allows
 * for the use of methods::new() in R.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_MODELS_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_MODELS_HPP

#include <set>
#include "../../../common/def.hpp"
#include "../../../models/fisheries_models.hpp"
#include "../../../utilities/fims_json.hpp"

#include "rcpp_interface_base.hpp"
#include "rcpp_population.hpp"
#include "rcpp_fleet.hpp"
#include "rcpp_maturity.hpp"
#include "rcpp_recruitment.hpp"
#include "rcpp_selectivity.hpp"
#include <valarray>
#include <cmath>
#include <mutex>

/**
 * @brief The FisheryModelInterfaceBase class is the base class for all fishery
 * models in the FIMS Rcpp interface. It inherits from the
 * FIMSRcppInterfaceBase.
 *
 */
class FisheryModelInterfaceBase : public FIMSRcppInterfaceBase {
 public:
  /**
   * @brief The static id of the FleetInterfaceBase object.
   */
  static uint32_t id_g;
  /**
   * @brief The local id of the FleetInterfaceBase object.
   */
  uint32_t id;
  /**
   * @brief The map associating the IDs of FleetInterfaceBase to the objects.
   * This is a live object, which is an object that has been created and lives
   * in memory.
   */
  static std::map<uint32_t, std::shared_ptr<FisheryModelInterfaceBase>>
      live_objects;

  /**
   * @brief The constructor.
   */
  FisheryModelInterfaceBase() {
    this->id = FisheryModelInterfaceBase::id_g++;
    /* Create instance of map: key is id and value is pointer to
    FleetInterfaceBase */
    // FisheryModelInterfaceBase::live_objects[this->id] = this;
  }

  /**
   * @brief Construct a new Data Interface Base object
   *
   * @param other
   */
  FisheryModelInterfaceBase(const FisheryModelInterfaceBase &other)
      : id(other.id) {}

  /**
   * @brief The destructor.
   */
  virtual ~FisheryModelInterfaceBase() {}

  /**
   * @brief Serialize the fishery model to a JSON string.
   *
   * This method provides a standardized interface for converting the state of
   * a fishery model into a JSON-formatted string. The JSON output is intended
   * for use in reporting, diagnostics, or data exchange between C++ and R.
   * Derived classes should override this method to provide model-specific
   * serialization logic.
   *
   * @return A JSON string representing the current state of the model. The
   * base implementation returns a placeholder string indicating the method is
   * not yet implemented.
   */
  virtual std::string to_json() {
    return "std::string to_json() not yet implemented.";
  }

  /**
   * @brief Get the ID for the child fleet interface objects to inherit.
   */
  virtual uint32_t get_id() = 0;
};
// static id of the FleetInterfaceBase object
uint32_t FisheryModelInterfaceBase::id_g = 1;

// FleetInterfaceBase to the FleetInterfaceBase objects
std::map<uint32_t, std::shared_ptr<FisheryModelInterfaceBase>>
    FisheryModelInterfaceBase::live_objects;

/**
 * @brief The CatchAtAgeInterface class is used to interface with the
 * CatchAtAge model. It inherits from the FisheryModelInterfaceBase class.
 */
class CatchAtAgeInterface : public FisheryModelInterfaceBase {
  /**
   * @brief The set of population ids that this catch at age model operates on.
   */
  std::shared_ptr<std::set<uint32_t>> population_ids;
  /**
   * @brief Iterator for population ids.
   */
  typedef typename std::set<uint32_t>::iterator population_id_iterator;

  /**
   * @brief A private working map of standard error values for all
   * concatenated derived quantities. Elements are extracted in the
   * to_json method.
   */
  std::map<std::string, std::vector<double>> se_values;

 public:
  /**
   * @brief The constructor.
   */
  CatchAtAgeInterface() : FisheryModelInterfaceBase() {
    this->population_ids = std::make_shared<std::set<uint32_t>>();
    std::shared_ptr<CatchAtAgeInterface> caa =
        std::make_shared<CatchAtAgeInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(caa);
    FisheryModelInterfaceBase::live_objects[this->id] = caa;
  }

  /**
   * @brief Construct a new Catch At Age Interface object
   *
   * @param other
   */
  CatchAtAgeInterface(const CatchAtAgeInterface &other)
      : FisheryModelInterfaceBase(other),
        population_ids(other.population_ids) {}

  /**
   * Method to add a population id to the set of population ids.
   */
  void AddPopulation(uint32_t id) {
    this->population_ids->insert(id);

    std::map<uint32_t, std::shared_ptr<PopulationInterfaceBase>>::iterator pit;
    pit = PopulationInterfaceBase::live_objects.find(id);
    if (pit != PopulationInterfaceBase::live_objects.end()) {
      std::shared_ptr<PopulationInterfaceBase> &pop = (*pit).second;
      pop->initialize_catch_at_age.set(true);
    } else {
      FIMS_ERROR_LOG("Population with id " + fims::to_string(id) +
                     " not found.");
    }
  }

  /**
   * @brief Enable or disable reporting for the CatchAtAge model.
   *
   * @details This method is used to control whether reporting is performed for
   * the CatchAtAge model. The implementation may depend on TMB_MODEL.
   * @param report Boolean flag to enable (true) or disable (false) reporting.
   */
  void DoReporting(bool report) {
#ifdef TMB_MODEL
    std::shared_ptr<fims_info::Information<double>> info =
        fims_info::Information<double>::GetInstance();
    typename fims_info::Information<double>::model_map_iterator model_it;
    model_it = info->models_map.find(this->get_id());
    if (model_it != info->models_map.end()) {
      std::shared_ptr<fims_popdy::CatchAtAge<double>> model_ptr =
          std::dynamic_pointer_cast<fims_popdy::CatchAtAge<double>>(
              (*model_it).second);
      model_ptr->do_reporting = report;
    }
#endif
  }

  /**
   * @brief Check if reporting is enabled for the CatchAtAge model.
   *
   * @details Returns true if reporting is enabled, false otherwise. The
   * implementation may depend on TMB_MODEL.
   * @return Boolean indicating reporting status.
   */
  bool IsReporting() {
#ifdef TMB_MODEL
    std::shared_ptr<fims_info::Information<double>> info =
        fims_info::Information<double>::GetInstance();
    typename fims_info::Information<double>::model_map_iterator model_it;
    model_it = info->models_map.find(this->get_id());
    if (model_it != info->models_map.end()) {
      std::shared_ptr<fims_popdy::CatchAtAge<double>> model_ptr =
          std::dynamic_pointer_cast<fims_popdy::CatchAtAge<double>>(
              (*model_it).second);
      return model_ptr->do_reporting;
    }
    return false;
#else
    return false;
#endif
  }

  /**
   * @brief Method to get this id.
   */
  virtual uint32_t get_id() { return this->id; }

  /**
   *
   */
  virtual void finalize() {}

  /**
   * @brief Method to convert a population to a JSON string.
   */
  std::string population_to_json(PopulationInterface *population_interface) {
    std::stringstream ss;

    typename std::map<uint32_t,
                      std::shared_ptr<PopulationInterfaceBase>>::iterator
        pi_it;  // population interface iterator
    pi_it = PopulationInterfaceBase::live_objects.find(
        population_interface->get_id());
    if (pi_it == PopulationInterfaceBase::live_objects.end()) {
      FIMS_ERROR_LOG("Population with id " +
                     fims::to_string(population_interface->get_id()) +
                     " not found in live objects.");
      return "{}";  // Return empty JSON
    }

    std::shared_ptr<PopulationInterface> population_interface_ptr =
        std::dynamic_pointer_cast<PopulationInterface>((*pi_it).second);

    std::shared_ptr<fims_info::Information<double>> info =
        fims_info::Information<double>::GetInstance();

    typename fims_info::Information<double>::model_map_iterator model_it;
    model_it = info->models_map.find(this->get_id());
    std::shared_ptr<fims_popdy::CatchAtAge<double>> model_ptr =
        std::dynamic_pointer_cast<fims_popdy::CatchAtAge<double>>(
            (*model_it).second);

    typename fims_info::Information<double>::population_iterator pit;

    pit = info->populations.find(population_interface->get_id());

    if (pit != info->populations.end()) {
      std::shared_ptr<fims_popdy::Population<double>> &pop = (*pit).second;
      ss << "{\n";

      ss << " \"module_name\": \"Population\",\n";
      ss << " \"population\": \"" << population_interface->name << "\",\n";
      ss << " \"module_id\": " << population_interface->id << ",\n";
      ss << " \"recruitment_id\": " << population_interface->recruitment_id
         << ",\n";
      ss << " \"growth_id\": " << population_interface->growth_id << ",\n";
      ss << " \"maturity_id\": " << population_interface->maturity_id << ",\n";

      ss << " \"parameters\": [\n";
      for (size_t i = 0; i < pop->log_M.size(); i++) {
        population_interface_ptr->log_M[i].final_value_m = pop->log_M[i];
      }

      ss << "{\n \"name\": \"log_M\",\n";
      ss << " \"id\":" << population_interface->log_M.id_m << ",\n";
      ss << " \"type\": \"vector\",\n";
      ss << " \"dimensionality\": {\n";
      ss << "  \"header\": [" << "\"n_years\", \"n_ages\"" << "],\n";
      ss << "  \"dimensions\": [" << population_interface->n_years.get() << ", "
         << population_interface->n_ages.get() << "]\n},\n";
      ss << " \"values\": " << population_interface->log_M << "\n\n";
      ss << "},\n";

      for (size_t i = 0; i < pop->log_f_multiplier.size(); i++) {
        population_interface_ptr->log_f_multiplier[i].final_value_m =
            pop->log_f_multiplier[i];
      }

      ss << "{\n \"name\": \"log_f_multiplier\",\n";
      ss << " \"id\":" << population_interface->log_f_multiplier.id_m << ",\n";
      ss << " \"type\": \"vector\",\n";
      ss << " \"dimensionality\": {\n";
      ss << "  \"header\": [" << "\"n_years\"" << "],\n";
      ss << "  \"dimensions\": [" << population_interface->n_years.get()
         << "]\n},\n";
      ss << " \"values\": " << population_interface->log_f_multiplier << "\n\n";
      ss << "},\n";

      for (size_t i = 0; i < pop->spawning_biomass_ratio.size(); i++) {
        population_interface_ptr->spawning_biomass_ratio[i].final_value_m =
            pop->spawning_biomass_ratio[i];
      }

      ss << "{\n \"name\": \"spawning_biomass_ratio\",\n";
      ss << " \"id\":" << population_interface->spawning_biomass_ratio.id_m
         << ",\n";
      ss << " \"type\": \"vector\",\n";
      ss << " \"dimensionality\": {\n";
      ss << "  \"header\": [" << "\"n_years\"" << "],\n";
      ss << "  \"dimensions\": [" << (population_interface->n_years.get() + 1)
         << "]\n},\n";
      ss << " \"values\": " << population_interface->spawning_biomass_ratio
         << "\n\n";
      ss << "},\n";

      for (size_t i = 0; i < pop->log_init_naa.size(); i++) {
        population_interface_ptr->log_init_naa[i].final_value_m =
            pop->log_init_naa[i];
      }
      ss << " {\n\"name\": \"log_init_naa\",\n";
      ss << "  \"id\":" << population_interface->log_init_naa.id_m << ",\n";
      ss << "  \"type\": \"vector\",\n";
      ss << " \"dimensionality\": {\n";
      ss << "  \"header\": [" << "\"n_ages\"" << "],\n";
      ss << "  \"dimensions\": [" << population_interface->n_ages.get()
         << "]\n},\n";

      ss << "  \"values\":" << population_interface->log_init_naa << "\n";
      ss << "}],\n";

      ss << " \"derived_quantities\": [\n";

      std::map<std::string, fims::Vector<double>> dqs =
          model_ptr->GetPopulationDerivedQuantities(
              population_interface->get_id());

      std::map<std::string, fims_popdy::DimensionInfo> dim_info =
          model_ptr->GetPopulationDimensionInfo(population_interface->get_id());
      ss << this->derived_quantities_component_to_json(dqs, dim_info)
         << " ]}\n";
    } else {
      ss << "{\n";
      ss << " \"name\": \"Population\",\n";

      ss << " \"type\": \"population\",\n";
      ss << " \"tag\": \"" << population_interface->get_id()
         << " not found in Information.\",\n";
      ss << " \"id\": " << population_interface->get_id() << ",\n";
      ss << " \"recruitment_id\": " << population_interface->recruitment_id
         << ",\n";
      ss << " \"growth_id\": " << population_interface->growth_id << ",\n";
      ss << " \"maturity_id\": " << population_interface->maturity_id << ",\n";
      ss << " \"derived_quantities\": []}\n";
    }

    return ss.str();
  }

  /**
   * This function is used to convert the derived quantities of a population or
   * fleet to a JSON string. This function is used to create the JSON output for
   * the CatchAtAge model.
   */
  std::string derived_quantity_to_json(
      std::map<std::string, fims::Vector<double>>::iterator it,
      const fims_popdy::DimensionInfo &dim_info) {
    std::stringstream ss;
    fims::Vector<double> &dq = (*it).second;
    std::stringstream dim_entry;
    // gather dimension information
    switch (dim_info.ndims) {
      case 1:
        dim_entry << "\"dimensionality\": {\n";
        dim_entry << "  \"header\": [\"" << dim_info.dim_names[0] << "\"],\n";
        dim_entry << "  \"dimensions\": [";
        for (size_t i = 0; i < dim_info.dims.size(); ++i) {
          if (i > 0) dim_entry << ", ";
          dim_entry << dim_info.dims[i];
        }
        dim_entry << "]\n";
        dim_entry << "}";
        break;
      case 2:
        dim_entry << "\"dimensionality\": {\n";
        dim_entry << "  \"header\": [\"" << dim_info.dim_names[0] << "\", \""
                  << dim_info.dim_names[1] << "\"],\n";
        dim_entry << "  \"dimensions\": [";
        for (size_t i = 0; i < dim_info.dims.size(); ++i) {
          if (i > 0) dim_entry << ", ";
          dim_entry << dim_info.dims[i];
        }
        dim_entry << "]\n";
        dim_entry << "}";
        break;
      case 3:
        dim_entry << "\"dimensionality\": {\n";
        dim_entry << "  \"header\": [\"" << dim_info.dim_names[0] << "\", \""
                  << dim_info.dim_names[1] << "\", \"" << dim_info.dim_names[2]
                  << "\"],\n";
        dim_entry << "  \"dimensions\": [";
        for (size_t i = 0; i < dim_info.dims.size(); ++i) {
          if (i > 0) dim_entry << ", ";
          dim_entry << dim_info.dims[i];
        }
        dim_entry << "]\n";
        dim_entry << "}";
        break;
      default:
        dim_entry << "\"dimensionality\": {\n";
        dim_entry << "  \"header\": [],\n";
        dim_entry << "  \"dimensions\": []\n";
        dim_entry << "}";
        break;
    }

    // build JSON string
    ss << "{\n";
    ss << "\"name\":\"" << (*it).first << "\",\n";
    ss << dim_entry.str() << ",\n";
    ss << "\"value\":[";
    ss << std::fixed << std::setprecision(10);
    if (dq.size() > 0) {
      for (size_t i = 0; i < dq.size() - 1; i++) {
        if (dq[i] != dq[i])  // check for NaN
        {
          ss << "-999" << ", ";
        } else {
          ss << dq[i] << ", ";
        }
      }
      if (dq[dq.size() - 1] != dq[dq.size() - 1])  // check for NaN
      {
        ss << "-999]" << "\n";
      } else {
        ss << dq[dq.size() - 1] << "]\n";
      }
    } else {
      ss << "]\n";
    }
    ss << "}";

    return ss.str();
  }

  /**
   * @brief Send the fleet-based derived quantities to the json file.
   * @return std::string
   */
  std::string derived_quantities_component_to_json(
      std::map<std::string, fims::Vector<double>> &dqs,
      std::map<std::string, fims_popdy::DimensionInfo> &dim_info) {
    std::stringstream ss;
    std::map<std::string, fims_popdy::DimensionInfo>::iterator dim_info_it;
    std::map<std::string, fims::Vector<double>>::iterator it;
    std::map<std::string, fims::Vector<double>>::iterator end_it;
    end_it = dqs.end();
    typename std::map<std::string, fims::Vector<double>>::iterator
        second_to_last;
    second_to_last = dqs.end();
    if (it != end_it) {
      second_to_last--;
    }

    it = dqs.begin();
    for (; it != second_to_last; ++it) {
      dim_info_it = dim_info.find(it->first);
      ss << this->derived_quantity_to_json(it, dim_info_it->second) << ",\n";
    }

    dim_info_it = dim_info.find(second_to_last->first);
    if (dim_info_it != dim_info.end()) {
      ss << this->derived_quantity_to_json(second_to_last, dim_info_it->second)
         << "\n";
    } else {
      ss << "{}";
      // Handle case where dimension info is not found
    }
    return ss.str();
  }

  /**
   * @brief Method to convert a fleet to a JSON string.
   */
  std::string fleet_to_json(FleetInterface *fleet_interface) {
    std::stringstream ss;

    if (!fleet_interface) {
      FIMS_ERROR_LOG(
          "Fleet pointer is null; cannot get id. Not found in live objects.");
      return "{}";  // Return empty JSON
    }

    std::shared_ptr<fims_info::Information<double>> info =
        fims_info::Information<double>::GetInstance();

    typename fims_info::Information<double>::model_map_iterator model_it;
    model_it = info->models_map.find(this->get_id());
    std::shared_ptr<fims_popdy::CatchAtAge<double>> model_ptr =
        std::dynamic_pointer_cast<fims_popdy::CatchAtAge<double>>(
            (*model_it).second);

    typename fims_info::Information<double>::fleet_iterator fit;

    fit = info->fleets.find(fleet_interface->get_id());

    if (fit != info->fleets.end()) {
      std::shared_ptr<fims_popdy::Fleet<double>> &fleet = (*fit).second;

      ss << "{\n";
      ss << " \"module_name\": \"Fleet\",\n";
      ss << " \"fleet\": \"" << fleet_interface->name << "\",\n";
      ss << " \"module_id\": " << fleet_interface->id << ",\n";
      ss << " \"n_ages\": " << fleet_interface->n_ages.get() << ",\n";
      ss << " \"n_years\": " << fleet_interface->n_years.get() << ",\n";
      ss << " \"n_lengths\": " << fleet_interface->n_lengths.get() << ",\n";
      ss << "\"data_ids\" : [\n";
      ss << "{\"agecomp\": " << fleet_interface->GetObservedAgeCompDataID()
         << "},\n";
      ss << "{\"lengthcomp\": "
         << fleet_interface->GetObservedLengthCompDataID() << "},\n";
      ss << "{\"index\": " << fleet_interface->GetObservedIndexDataID()
         << "},\n";
      ss << "{\"landings\": " << fleet_interface->GetObservedLandingsDataID()
         << "}\n";
      ss << "],\n";
      ss << "\"parameters\": [\n";
      ss << "{\n";
      for (size_t i = 0; i < fleet_interface->log_Fmort.size(); i++) {
        fleet_interface->log_Fmort[i].final_value_m = fleet->log_Fmort[i];
      }

      ss << " \"name\": \"log_Fmort\",\n";
      ss << " \"id\":" << fleet_interface->log_Fmort.id_m << ",\n";
      ss << " \"type\": \"vector\",\n";
      ss << " \"dimensionality\": {\n";
      ss << "  \"header\": [\"" << "n_years" << "\"],\n";
      ss << "  \"dimensions\": [" << fleet_interface->n_years.get()
         << "]\n},\n";
      ss << " \"values\": " << fleet_interface->log_Fmort << "},\n";

      ss << " {\n";
      for (size_t i = 0; i < fleet->log_q.size(); i++) {
        fleet_interface->log_q[i].final_value_m = fleet->log_q[i];
      }
      ss << " \"name\": \"log_q\",\n";
      ss << " \"id\":" << fleet_interface->log_q.id_m << ",\n";
      ss << " \"type\": \"vector\",\n";
      ss << " \"dimensionality\": {\n";
      ss << "  \"header\": [\"" << "na" << "\"],\n";
      ss << "  \"dimensions\": [" << fleet->log_q.size() << "]\n},\n";

      ss << " \"values\": " << fleet_interface->log_q << "}\n";

      ss << "], \"derived_quantities\": [";

      std::map<std::string, fims::Vector<double>> dqs =
          model_ptr->GetFleetDerivedQuantities(fleet_interface->get_id());
      std::map<std::string, fims_popdy::DimensionInfo> dim_info =
          model_ptr->GetFleetDimensionInfo(fleet_interface->get_id());
      ss << this->derived_quantities_component_to_json(dqs, dim_info) << "]}\n";
    } else {
      ss << "{\n";
      ss << " \"name\": \"Fleet\",\n";
      ss << " \"type\": \"fleet\",\n";
      ss << " \"tag\": \"" << fleet_interface->get_id()
         << " not found in Information.\",\n";
      ss << " \"derived_quantities\": []}\n";
    }
    return ss.str();
  }

  /**
   * @brief Get the vector of fixed effect parameters for the CatchAtAge model.
   *
   * @details Returns a numeric vector containing the fixed effect parameters
   * used in the model.
   * @return Rcpp::NumericVector of fixed effect parameters.
   */
  Rcpp::NumericVector get_fixed_parameters_vector() {
    // base model
    std::shared_ptr<fims_info::Information<double>> info0 =
        fims_info::Information<double>::GetInstance();

    Rcpp::NumericVector p;

    for (size_t i = 0; i < info0->fixed_effects_parameters.size(); i++) {
      p.push_back(*info0->fixed_effects_parameters[i]);
    }

    return p;
  }

  /**
   * @brief Get the vector of random effect parameters for the CatchAtAge model.
   *
   * @details Returns a numeric vector containing the random effect parameters
   * used in the model.
   * @return Rcpp::NumericVector of random effect parameters.
   */
  Rcpp::NumericVector get_random_parameters_vector() {
    // base model
    std::shared_ptr<fims_info::Information<double>> d0 =
        fims_info::Information<double>::GetInstance();

    Rcpp::NumericVector p;

    for (size_t i = 0; i < d0->random_effects_parameters.size(); i++) {
      p.push_back(*d0->random_effects_parameters[i]);
    }

    return p;
  }

  /**
   * @copydoc FisheryModelInterfaceBase::to_json
   */
  virtual std::string to_json() {
    std::set<uint32_t> recruitment_ids;
    std::set<uint32_t> growth_ids;
    std::set<uint32_t> maturity_ids;
    std::set<uint32_t> selectivity_ids;
    std::set<uint32_t> fleet_ids;
    // gather sub-module info from population and fleets
    typename std::set<uint32_t>::iterator module_id_it;  // generic
    typename std::set<uint32_t>::iterator pit;
    typename std::set<uint32_t>::iterator fids;
    for (pit = this->population_ids->begin();
         pit != this->population_ids->end(); pit++) {
      std::shared_ptr<PopulationInterface> population_interface =
          std::dynamic_pointer_cast<PopulationInterface>(
              PopulationInterfaceBase::live_objects[*pit]);
      if (population_interface) {
        recruitment_ids.insert(population_interface->recruitment_id.get());
        growth_ids.insert(population_interface->growth_id.get());
        maturity_ids.insert(population_interface->maturity_id.get());

        for (fids = population_interface->fleet_ids->begin();
             fids != population_interface->fleet_ids->end(); fids++) {
          fleet_ids.insert(*fids);
        }
      }
    }

    for (fids = fleet_ids.begin(); fids != fleet_ids.end(); fids++) {
      std::shared_ptr<FleetInterface> fleet_interface =
          std::dynamic_pointer_cast<FleetInterface>(
              FleetInterfaceBase::live_objects[*fids]);
      if (fleet_interface) {
        selectivity_ids.insert(fleet_interface->GetSelectivityID());
      }
    }

    std::shared_ptr<fims_info::Information<double>> info =
        fims_info::Information<double>::GetInstance();

    std::shared_ptr<fims_popdy::CatchAtAge<double>> model =
        std::dynamic_pointer_cast<fims_popdy::CatchAtAge<double>>(
            info->models_map[this->get_id()]);

    std::shared_ptr<fims_model::Model<double>> model_internal =
        fims_model::Model<double>::GetInstance();

#ifdef TMB_MODEL
    model->do_reporting = false;
#endif

    double value = model_internal->Evaluate();

    std::stringstream ss;

    ss.str("");

    ss << "{\n";
    ss << " \"name\": \"CatchAtAge\",\n";
    ss << " \"type\": \"model\",\n";
    ss << " \"estimation_framework\": ";
#ifdef TMB_MODEL
    ss << "\"Template_Model_Builder (TMB)\",";
#else
    ss << "\"FIMS\",";
#endif
    ss << " \"id\": " << this->get_id() << ",\n";
    ss << " \"objective_function_value\": " << value << ",\n";
    ss << "\"growth\":[\n";
    for (module_id_it = growth_ids.begin(); module_id_it != growth_ids.end();
         module_id_it++) {
      std::shared_ptr<GrowthInterfaceBase> growth_interface =
          GrowthInterfaceBase::live_objects[*module_id_it];

      if (growth_interface != NULL) {
        growth_interface->finalize();
        ss << growth_interface->to_json();
        if (std::next(module_id_it) != growth_ids.end()) {
          ss << ", ";
        }
      }
    }

    ss << "],\n";

    ss << "\"recruitment\": [\n";
    for (module_id_it = recruitment_ids.begin();
         module_id_it != recruitment_ids.end(); module_id_it++) {
      std::shared_ptr<RecruitmentInterfaceBase> recruitment_interface =
          RecruitmentInterfaceBase::live_objects[*module_id_it];
      if (recruitment_interface) {
        recruitment_interface->finalize();
        ss << recruitment_interface->to_json();
        if (std::next(module_id_it) != recruitment_ids.end()) {
          ss << ", ";
        }
      }
    }
    ss << "],\n";

    ss << "\"maturity\": [\n";
    for (module_id_it = maturity_ids.begin();
         module_id_it != maturity_ids.end(); module_id_it++) {
      std::shared_ptr<MaturityInterfaceBase> maturity_interface =
          MaturityInterfaceBase::live_objects[*module_id_it];
      if (maturity_interface) {
        maturity_interface->finalize();
        ss << maturity_interface->to_json();
        if (std::next(module_id_it) != maturity_ids.end()) {
          ss << ", ";
        }
      }
    }
    ss << "],\n";

    ss << "\"selectivity\": [\n";
    for (module_id_it = selectivity_ids.begin();
         module_id_it != selectivity_ids.end(); module_id_it++) {
      std::shared_ptr<SelectivityInterfaceBase> selectivity_interface =
          SelectivityInterfaceBase::live_objects[*module_id_it];
      if (selectivity_interface) {
        selectivity_interface->finalize();
        ss << selectivity_interface->to_json();
        if (std::next(module_id_it) != selectivity_ids.end()) {
          ss << ", ";
        }
      }
    }
    ss << "],\n";

    ss << " \"population_ids\": [";
    for (pit = this->population_ids->begin();
         pit != this->population_ids->end(); pit++) {
      ss << *pit;
      if (std::next(pit) != this->population_ids->end()) {
        ss << ", ";
      }
    }
    ss << "],\n";
    ss << " \"fleet_ids\": [";

    for (fids = fleet_ids.begin(); fids != fleet_ids.end(); fids++) {
      ss << *fids;
      if (std::next(fids) != fleet_ids.end()) {
        ss << ", ";
      }
    }
    ss << "],\n";
    ss << "\"populations\": [\n";
    typename std::set<uint32_t>::iterator pop_it;
    typename std::set<uint32_t>::iterator pop_end_it;
    pop_end_it = this->population_ids->end();
    typename std::set<uint32_t>::iterator pop_second_to_last_it;
    if (pop_end_it != this->population_ids->begin()) {
      pop_second_to_last_it = std::prev(pop_end_it);
    } else {
      pop_second_to_last_it = pop_end_it;
    }
    for (pop_it = this->population_ids->begin();
         pop_it != pop_second_to_last_it; pop_it++) {
      std::shared_ptr<PopulationInterface> population_interface =
          std::dynamic_pointer_cast<PopulationInterface>(
              PopulationInterfaceBase::live_objects[*pop_it]);
      if (population_interface) {
        std::set<uint32_t>::iterator fids;
        for (fids = population_interface->fleet_ids->begin();
             fids != population_interface->fleet_ids->end(); fids++) {
          fleet_ids.insert(*fids);
        }
        population_interface->finalize();
        ss << this->population_to_json(population_interface.get()) << ",";
      } else {
        FIMS_ERROR_LOG("Population with id " + fims::to_string(*pop_it) +
                       " not found in live objects.");
        ss << "{}";  // Return empty JSON for this population
      }
    }

    std::shared_ptr<PopulationInterface> population_interface =
        std::dynamic_pointer_cast<PopulationInterface>(
            PopulationInterfaceBase::live_objects[*pop_second_to_last_it]);
    if (population_interface) {
      std::set<uint32_t>::iterator fids;
      for (fids = population_interface->fleet_ids->begin();
           fids != population_interface->fleet_ids->end(); fids++) {
        fleet_ids.insert(*fids);
      }
      ss << this->population_to_json(population_interface.get());
    } else {
      FIMS_ERROR_LOG("Population with id " + fims::to_string(*pop_it) +
                     " not found in live objects.");
      ss << "{}";  // Return empty JSON for this population
    }

    ss << "]";
    ss << ",\n";
    ss << "\"fleets\": [\n";

    typename std::set<uint32_t>::iterator fleet_it;
    typename std::set<uint32_t>::iterator fleet_end_it;
    fleet_end_it = fleet_ids.end();
    typename std::set<uint32_t>::iterator fleet_second_to_last_it;

    if (fleet_end_it != fleet_ids.begin()) {
      fleet_second_to_last_it = std::prev(fleet_end_it);
    }
    for (fleet_it = fleet_ids.begin(); fleet_it != fleet_second_to_last_it;
         fleet_it++) {
      std::shared_ptr<FleetInterface> fleet_interface =
          std::dynamic_pointer_cast<FleetInterface>(
              FleetInterfaceBase::live_objects[*fleet_it]);
      if (fleet_interface) {
        fleet_interface->finalize();
        ss << this->fleet_to_json(fleet_interface.get()) << ",";
      } else {
        FIMS_ERROR_LOG("Fleet with id " + fims::to_string(*fleet_it) +
                       " not found in live objects.");
        ss << "{}";  // Return empty JSON for this fleet
      }
    }
    std::shared_ptr<FleetInterface> fleet_interface =
        std::dynamic_pointer_cast<FleetInterface>(
            FleetInterfaceBase::live_objects[*fleet_second_to_last_it]);
    if (fleet_interface) {
      ss << this->fleet_to_json(fleet_interface.get());
    } else {
      FIMS_ERROR_LOG("Fleet with id " + fims::to_string(*fleet_it) +
                     " not found in live objects.");
      ss << "{}";  // Return empty JSON for this fleet
    }

    ss << "],\n";

    ss << "\"density_components\": [\n";

    typename std::map<
        uint32_t, std::shared_ptr<DistributionsInterfaceBase>>::iterator dit;
    for (dit = DistributionsInterfaceBase::live_objects.begin();
         dit != DistributionsInterfaceBase::live_objects.end(); ++dit) {
      std::shared_ptr<DistributionsInterfaceBase> dist_interface =
          (*dit).second;
      if (dist_interface) {
        dist_interface->finalize();
        ss << dist_interface->to_json();
        if (std::next(dit) != DistributionsInterfaceBase::live_objects.end()) {
          ss << ",\n";
        }
      }
    }
    ss << "\n],\n";
    ss << "\"data\": [\n";
    typename std::map<uint32_t, std::shared_ptr<DataInterfaceBase>>::iterator
        d_it;
    for (d_it = DataInterfaceBase::live_objects.begin();
         d_it != DataInterfaceBase::live_objects.end(); ++d_it) {
      std::shared_ptr<DataInterfaceBase> data_interface = (*d_it).second;
      if (data_interface) {
        data_interface->finalize();
        ss << data_interface->to_json();
        if (std::next(d_it) != DataInterfaceBase::live_objects.end()) {
          ss << ",\n";
        }
      }
    }
    ss << "\n],\n";
    // add log
    ss << " \"log\": {\n";
    ss << "\"info\": " << fims::FIMSLog::fims_log->get_info() << ","
       << "\"warnings\": " << fims::FIMSLog::fims_log->get_warnings() << ","
       << "\"errors\": " << fims::FIMSLog::fims_log->get_errors() << "}}";
#ifdef TMB_MODEL
    model->do_reporting = true;
#endif
    return fims::JsonParser::PrettyFormatJSON(ss.str());
  }

  /**
   * @brief Sum method to calculate the sum of an array or vector of doubles.
   *
   * @param v
   * @return double
   */
  double sum(const std::valarray<double> &v) {
    double sum = 0.0;
    for (size_t i = 0; i < v.size(); i++) {
      sum += v[i];
    }
    return sum;
  }

  /**
   * @brief Sum method for a vector of doubles.
   *
   * @param v
   * @return double
   */
  double sum(const std::vector<double> &v) {
    double sum = 0.0;
    for (size_t i = 0; i < v.size(); i++) {
      sum += v[i];
    }
    return sum;
  }

  /**
   * @brief Minimum method to calculate the minimum of an array or vector
   * of doubles.
   *
   * @param v
   * @return double
   */
  double min(const std::valarray<double> &v) {
    double min = v[0];
    for (size_t i = 1; i < v.size(); i++) {
      if (v[i] < min) {
        min = v[i];
      }
    }
    return min;
  }
  /**
   * @brief A function to compute the absolute value of a value array of
   * floating-point values. It is a wrapper around std::fabs.
   *
   * @param v A value array of floating-point values, where floating-point
   * values is anything with decimals.
   * @return std::valarray<double>
   */
  std::valarray<double> fabs(const std::valarray<double> &v) {
    std::valarray<double> result(v.size());
    for (size_t i = 0; i < v.size(); i++) {
      result[i] = std::fabs(v[i]);
    }
    return result;
  }

#ifdef TMB_MODEL

  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();

    std::shared_ptr<fims_popdy::CatchAtAge<Type>> model =
        std::make_shared<fims_popdy::CatchAtAge<Type>>();

    population_id_iterator it;

    for (it = this->population_ids->begin(); it != this->population_ids->end();
         ++it) {
      model->AddPopulation((*it));
    }

    std::set<uint32_t> fleet_ids;  // all fleets in the model
    typedef typename std::set<uint32_t>::iterator fleet_ids_iterator;

    // add to Information
    info->models_map[this->get_id()] = model;

    for (it = this->population_ids->begin(); it != this->population_ids->end();
         ++it) {
      auto it2 = PopulationInterfaceBase::live_objects.find(*it);
      if (it2 == PopulationInterfaceBase::live_objects.end()) {
        throw std::runtime_error("Population ID " + std::to_string(*it) +
                                 " not found in live_objects");
      }
      auto population =
          std::dynamic_pointer_cast<PopulationInterface>(it2->second);
      model->InitializePopulationDerivedQuantities(population->id);
      std::map<std::string, fims::Vector<Type>> &derived_quantities =
          model->GetPopulationDerivedQuantities(population->id);

      std::map<std::string, fims_popdy::DimensionInfo>
          &derived_quantities_dim_info =
              model->GetPopulationDimensionInfo(population->id);

      std::stringstream ss;

      derived_quantities["total_landings_weight"] =
          fims::Vector<Type>(population->n_years.get());

      derived_quantities_dim_info["total_landings_weight"] =
          fims_popdy::DimensionInfo(
              "total_landings_weight",
              fims::Vector<int>{(int)population->n_years.get()},
              fims::Vector<std::string>{"n_years"});

      derived_quantities["total_landings_numbers"] =
          fims::Vector<Type>(population->n_years.get());

      derived_quantities_dim_info["total_landings_numbers"] =
          fims_popdy::DimensionInfo(
              "total_landings_numbers",
              fims::Vector<int>{population->n_years.get()},
              fims::Vector<std::string>{"n_years"});

      derived_quantities["mortality_F"] = fims::Vector<Type>(
          population->n_years.get() * population->n_ages.get());
      derived_quantities_dim_info["mortality_F"] = fims_popdy::DimensionInfo(
          "mortality_F",
          fims::Vector<int>{population->n_years.get(),
                            population->n_ages.get()},
          fims::Vector<std::string>{"n_years", "n_ages"});

      derived_quantities["mortality_M"] = fims::Vector<Type>(
          population->n_years.get() * population->n_ages.get());
      derived_quantities_dim_info["mortality_M"] = fims_popdy::DimensionInfo(
          "mortality_M",
          fims::Vector<int>{population->n_years.get(),
                            population->n_ages.get()},
          fims::Vector<std::string>{"n_years", "n_ages"});

      derived_quantities["mortality_Z"] = fims::Vector<Type>(
          population->n_years.get() * population->n_ages.get());
      derived_quantities_dim_info["mortality_Z"] = fims_popdy::DimensionInfo(
          "mortality_Z",
          fims::Vector<int>{population->n_years.get(),
                            population->n_ages.get()},
          fims::Vector<std::string>{"n_years", "n_ages"});

      derived_quantities["numbers_at_age"] = fims::Vector<Type>(
          (population->n_years.get() + 1) * population->n_ages.get());
      derived_quantities_dim_info["numbers_at_age"] = fims_popdy::DimensionInfo(
          "numbers_at_age",
          fims::Vector<int>{(population->n_years.get() + 1),
                            population->n_ages.get()},
          fims::Vector<std::string>{"n_years+1", "n_ages"});

      derived_quantities["unfished_numbers_at_age"] = fims::Vector<Type>(
          (population->n_years.get() + 1) * population->n_ages.get());
      derived_quantities_dim_info["unfished_numbers_at_age"] =
          fims_popdy::DimensionInfo(
              "unfished_numbers_at_age",
              fims::Vector<int>{(population->n_years.get() + 1),
                                population->n_ages.get()},
              fims::Vector<std::string>{"n_years+1", "n_ages"});

      derived_quantities["biomass"] =
          fims::Vector<Type>((population->n_years.get() + 1));
      derived_quantities_dim_info["biomass"] = fims_popdy::DimensionInfo(
          "biomass", fims::Vector<int>{(population->n_years.get() + 1)},
          fims::Vector<std::string>{"n_years+1"});

      derived_quantities["spawning_biomass"] =
          fims::Vector<Type>((population->n_years.get() + 1));
      derived_quantities_dim_info["spawning_biomass"] =
          fims_popdy::DimensionInfo(
              "spawning_biomass",
              fims::Vector<int>{(population->n_years.get() + 1)},
              fims::Vector<std::string>{"n_years+1"});

      derived_quantities["unfished_biomass"] =
          fims::Vector<Type>((population->n_years.get() + 1));
      derived_quantities_dim_info["unfished_biomass"] =
          fims_popdy::DimensionInfo(
              "unfished_biomass",
              fims::Vector<int>{(population->n_years.get() + 1)},
              fims::Vector<std::string>{"n_years+1"});

      derived_quantities["unfished_spawning_biomass"] =
          fims::Vector<Type>((population->n_years.get() + 1));
      derived_quantities_dim_info["unfished_spawning_biomass"] =
          fims_popdy::DimensionInfo(
              "unfished_spawning_biomass",
              fims::Vector<int>{(population->n_years.get() + 1)},
              fims::Vector<std::string>{"n_years+1"});

      derived_quantities["proportion_mature_at_age"] = fims::Vector<Type>(
          (population->n_years.get() + 1) * population->n_ages.get());
      derived_quantities_dim_info["proportion_mature_at_age"] =
          fims_popdy::DimensionInfo(
              "proportion_mature_at_age",
              fims::Vector<int>{(population->n_years.get() + 1),
                                population->n_ages.get()},
              fims::Vector<std::string>{"n_years+1", "n_ages"});

      derived_quantities["expected_recruitment"] =
          fims::Vector<Type>((population->n_years.get() + 1));
      derived_quantities_dim_info["expected_recruitment"] =
          fims_popdy::DimensionInfo(
              "expected_recruitment",
              fims::Vector<int>{(population->n_years.get() + 1)},
              fims::Vector<std::string>{"n_years+1"});

      derived_quantities["sum_selectivity"] = fims::Vector<Type>(
          population->n_years.get() * population->n_ages.get());
      derived_quantities_dim_info["sum_selectivity"] =
          fims_popdy::DimensionInfo(
              "sum_selectivity",
              fims::Vector<int>{population->n_years.get(),
                                population->n_ages.get()},
              fims::Vector<std::string>{"n_years", "n_ages"});

      // replace elements in the variable map

      for (fleet_ids_iterator fit = population->fleet_ids->begin();
           fit != population->fleet_ids->end(); ++fit) {
        fleet_ids.insert(*fit);
      }
    }

    for (fleet_ids_iterator it = fleet_ids.begin(); it != fleet_ids.end();
         ++it) {
      std::shared_ptr<FleetInterface> fleet_interface =
          std::dynamic_pointer_cast<FleetInterface>(
              FleetInterfaceBase::live_objects[(*it)]);
      model->InitializeFleetDerivedQuantities(fleet_interface->id);
      std::map<std::string, fims::Vector<Type>> &derived_quantities =
          model->GetFleetDerivedQuantities(fleet_interface->id);

      std::map<std::string, fims_popdy::DimensionInfo>
          &derived_quantities_dim_info =
              model->GetFleetDimensionInfo(fleet_interface->id);

      // initialize derive quantities
      // landings
      derived_quantities["landings_numbers_at_age"] = fims::Vector<Type>(
          fleet_interface->n_years.get() * fleet_interface->n_ages.get());
      derived_quantities_dim_info["landings_numbers_at_age"] =
          fims_popdy::DimensionInfo(
              "landings_numbers_at_age",
              fims::Vector<int>{(fleet_interface->n_years.get()),
                                fleet_interface->n_ages.get()},
              fims::Vector<std::string>{"n_years", "n_ages"});

      derived_quantities["landings_weight_at_age"] = fims::Vector<Type>(
          fleet_interface->n_years.get() * fleet_interface->n_ages.get());
      derived_quantities_dim_info["landings_weight_at_age"] =
          fims_popdy::DimensionInfo(
              "landings_weight_at_age",
              fims::Vector<int>{(fleet_interface->n_years.get()),
                                fleet_interface->n_ages.get()},
              fims::Vector<std::string>{"n_years", "n_ages"});

      derived_quantities["landings_numbers_at_length"] = fims::Vector<Type>(
          fleet_interface->n_years.get() * fleet_interface->n_lengths.get());
      derived_quantities_dim_info["landings_numbers_at_length"] =
          fims_popdy::DimensionInfo(
              "landings_numbers_at_length",
              fims::Vector<int>{(fleet_interface->n_years.get()),
                                fleet_interface->n_lengths.get()},
              fims::Vector<std::string>{"n_years", "n_lengths"});

      derived_quantities["landings_weight"] =
          fims::Vector<Type>(fleet_interface->n_years.get());
      derived_quantities_dim_info["landings_weight"] =
          fims_popdy::DimensionInfo(
              "landings_weight",
              fims::Vector<int>{(fleet_interface->n_years.get())},
              fims::Vector<std::string>{"n_years"});

      derived_quantities["landings_numbers"] =
          fims::Vector<Type>(fleet_interface->n_years.get());
      derived_quantities_dim_info["landings_numbers"] =
          fims_popdy::DimensionInfo(
              "landings_numbers",
              fims::Vector<int>{(fleet_interface->n_years.get())},
              fims::Vector<std::string>{"n_years"});

      derived_quantities["landings_expected"] =
          fims::Vector<Type>(fleet_interface->n_years.get());
      derived_quantities_dim_info["landings_expected"] =
          fims_popdy::DimensionInfo(
              "landings_expected",
              fims::Vector<int>{(fleet_interface->n_years.get())},
              fims::Vector<std::string>{"n_years"});

      derived_quantities["log_landings_expected"] =
          fims::Vector<Type>(fleet_interface->n_years.get());
      derived_quantities_dim_info["log_landings_expected"] =
          fims_popdy::DimensionInfo(
              "log_landings_expected",
              fims::Vector<int>{(fleet_interface->n_years.get())},
              fims::Vector<std::string>{"n_years"});

      derived_quantities["agecomp_proportion"] = fims::Vector<Type>(
          fleet_interface->n_years.get() * fleet_interface->n_ages.get());
      derived_quantities_dim_info["agecomp_proportion"] =
          fims_popdy::DimensionInfo(
              "agecomp_proportion",
              fims::Vector<int>{(fleet_interface->n_years.get()),
                                fleet_interface->n_ages.get()},
              fims::Vector<std::string>{"n_years", "n_ages"});

      derived_quantities["lengthcomp_proportion"] = fims::Vector<Type>(
          fleet_interface->n_years.get() * fleet_interface->n_lengths.get());
      derived_quantities_dim_info["lengthcomp_proportion"] =
          fims_popdy::DimensionInfo(
              "lengthcomp_proportion",
              fims::Vector<int>{(fleet_interface->n_years.get()),
                                fleet_interface->n_lengths.get()},
              fims::Vector<std::string>{"n_years", "n_lengths"});

      // index
      derived_quantities["index_numbers_at_age"] = fims::Vector<Type>(
          fleet_interface->n_years.get() * fleet_interface->n_ages.get());
      derived_quantities_dim_info["index_numbers_at_age"] =
          fims_popdy::DimensionInfo(
              "index_numbers_at_age",
              fims::Vector<int>{(fleet_interface->n_years.get()),
                                fleet_interface->n_ages.get()},
              fims::Vector<std::string>{"n_years", "n_ages"});

      derived_quantities["index_weight_at_age"] = fims::Vector<Type>(
          fleet_interface->n_years.get() * fleet_interface->n_ages.get());
      derived_quantities_dim_info["index_weight_at_age"] =
          fims_popdy::DimensionInfo(
              "index_weight_at_age",
              fims::Vector<int>{(fleet_interface->n_years.get()),
                                fleet_interface->n_ages.get()},
              fims::Vector<std::string>{"n_years", "n_ages"});

      derived_quantities["index_weight_at_age"] = fims::Vector<Type>(
          fleet_interface->n_years.get() * fleet_interface->n_ages.get());
      derived_quantities_dim_info["index_weight_at_age"] =
          fims_popdy::DimensionInfo(
              "index_weight_at_age",
              fims::Vector<int>{(fleet_interface->n_years.get()),
                                fleet_interface->n_ages.get()},
              fims::Vector<std::string>{"n_years", "n_ages"});

      derived_quantities["index_numbers_at_length"] = fims::Vector<Type>(
          fleet_interface->n_years.get() * fleet_interface->n_lengths.get());
      derived_quantities_dim_info["index_numbers_at_length"] =
          fims_popdy::DimensionInfo(
              "index_numbers_at_length",
              fims::Vector<int>{(fleet_interface->n_years.get()),
                                fleet_interface->n_lengths.get()},
              fims::Vector<std::string>{"n_years", "n_lengths"});
      derived_quantities["index_weight"] =
          fims::Vector<Type>(fleet_interface->n_years.get());
      derived_quantities_dim_info["index_weight"] = fims_popdy::DimensionInfo(
          "index_weight", fims::Vector<int>{(fleet_interface->n_years.get())},
          fims::Vector<std::string>{"n_years"});

      derived_quantities["index_numbers"] =
          fims::Vector<Type>(fleet_interface->n_years.get());
      derived_quantities_dim_info["index_numbers"] = fims_popdy::DimensionInfo(
          "index_numbers", fims::Vector<int>{(fleet_interface->n_years.get())},
          fims::Vector<std::string>{"n_years"});

      derived_quantities["index_expected"] =
          fims::Vector<Type>(fleet_interface->n_years.get());
      derived_quantities_dim_info["index_expected"] = fims_popdy::DimensionInfo(
          "index_expected", fims::Vector<int>{(fleet_interface->n_years.get())},
          fims::Vector<std::string>{"n_years"});

      derived_quantities["log_index_expected"] =
          fims::Vector<Type>(fleet_interface->n_years.get());
      derived_quantities_dim_info["log_index_expected"] =
          fims_popdy::DimensionInfo(
              "log_index_expected",
              fims::Vector<int>{(fleet_interface->n_years.get())},
              fims::Vector<std::string>{"n_years"});

      derived_quantities["catch_index"] =
          fims::Vector<Type>(fleet_interface->n_years.get());
      derived_quantities_dim_info["catch_index"] = fims_popdy::DimensionInfo(
          "catch_index", fims::Vector<int>{(fleet_interface->n_years.get())},
          fims::Vector<std::string>{"n_years"});

      derived_quantities["agecomp_expected"] = fims::Vector<Type>(
          fleet_interface->n_years.get() * fleet_interface->n_ages.get());
      derived_quantities_dim_info["agecomp_expected"] =
          fims_popdy::DimensionInfo(
              "agecomp_expected",
              fims::Vector<int>{(fleet_interface->n_years.get()),
                                (fleet_interface->n_ages.get())},
              fims::Vector<std::string>{"n_years", "n_ages"});

      derived_quantities["lengthcomp_expected"] = fims::Vector<Type>(
          fleet_interface->n_years.get() * fleet_interface->n_lengths.get());
      derived_quantities_dim_info["lengthcomp_expected"] =
          fims_popdy::DimensionInfo(
              "lengthcomp_expected",
              fims::Vector<int>{(fleet_interface->n_years.get()),
                                (fleet_interface->n_lengths.get())},
              fims::Vector<std::string>{"n_years", "n_lengths"});

      // replace elements in the variable map
      info->variable_map[fleet_interface->log_landings_expected.id_m] =
          &(derived_quantities["log_landings_expected"]);
      info->variable_map[fleet_interface->log_index_expected.id_m] =
          &(derived_quantities["log_index_expected"]);
      info->variable_map[fleet_interface->agecomp_expected.id_m] =
          &(derived_quantities["agecomp_expected"]);
      info->variable_map[fleet_interface->agecomp_proportion.id_m] =
          &(derived_quantities["agecomp_proportion"]);
      info->variable_map[fleet_interface->lengthcomp_expected.id_m] =
          &(derived_quantities["lengthcomp_expected"]);
      info->variable_map[fleet_interface->lengthcomp_proportion.id_m] =
          &(derived_quantities["lengthcomp_proportion"]);
    }

    return true;
  }

  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
    return true;
  }

#endif
};

#endif

/**
 * @file rcpp_population.hpp
 * @brief The Rcpp interface to declare different types of populations. Allows
 * for the use of methods::new() in R.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_POPULATION_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_POPULATION_HPP

#include "../../../population_dynamics/population/population.hpp"
#include "rcpp_interface_base.hpp"

/**
 * @brief Rcpp interface that serves as the parent class for Rcpp population
 * interfaces. This type should be inherited and not called from R directly.
 */
class PopulationInterfaceBase : public FIMSRcppInterfaceBase {
 public:
  /**
   * @brief The static id of the PopulationInterfaceBase object.
   */
  static uint32_t id_g;
  /**
   * @brief The local id of the PopulationInterfaceBase object.
   */
  uint32_t id;
  /**
   * @brief The map associating the IDs of PopulationInterfaceBase to the
   * objects. This is a live object, which is an object that has been created
   * and lives in memory.
   */
  static std::map<uint32_t, std::shared_ptr<PopulationInterfaceBase>>
      live_objects;

  /**
   * @brief Initialize the catch at age model.
   *
   */
  SharedBoolean initialize_catch_at_age;
  /**
   * @brief Initialize the surplus production model.
   *
   */
  SharedBoolean initialize_surplus_production;
  /**
   * @brief The constructor.
   */
  PopulationInterfaceBase() {
    this->id = PopulationInterfaceBase::id_g++;
    /* Create instance of map: key is id and value is pointer to
    PopulationInterfaceBase */
    // PopulationInterfaceBase::live_objects[this->id] = this;
  }

  /**
   * @brief Construct a new Population Interface Base object
   *
   * @param other
   */
  PopulationInterfaceBase(const PopulationInterfaceBase &other)
      : id(other.id) {}

  /**
   * @brief The destructor.
   */
  virtual ~PopulationInterfaceBase() {}

  /**
   * @brief Get the ID for the child population interface objects to inherit.
   */
  virtual uint32_t get_id() = 0;
};
// static id of the PopulationInterfaceBase object
uint32_t PopulationInterfaceBase::id_g = 1;
// local id of the PopulationInterfaceBase object map relating the ID of the
// PopulationInterfaceBase to the PopulationInterfaceBase objects
std::map<uint32_t, std::shared_ptr<PopulationInterfaceBase>>
    PopulationInterfaceBase::live_objects;

/**
 * @brief Rcpp interface for a new Population to instantiate from R:
 * population <- methods::new(population)
 */
class PopulationInterface : public PopulationInterfaceBase {
 public:
  /**
   * @brief The number of age bins.
   */
  SharedInt n_ages = 0;
  /**
   * @brief The number of fleets.
   */
  SharedInt n_fleets;
  /**
   * list of fleets that operate on this population.
   */
  std::shared_ptr<std::set<uint32_t>> fleet_ids;
  /**
   * Iterator for fleet ids.
   */
  typedef typename std::set<uint32_t>::iterator fleet_ids_iterator;
  /**
   * @brief The number of years.
   */
  SharedInt n_years;
  /**
   * @brief The number of length bins.
   */
  SharedInt n_lengths;
  /**
   * @brief The ID of the maturity module.
   */
  SharedInt maturity_id;
  /**
   * @brief The ID of the growth module.
   */
  SharedInt growth_id;
  /**
   * @brief The ID of the recruitment module.
   */
  SharedInt recruitment_id;
  /**
   * @brief The ID of the recruitment process module.
   */
  SharedInt recruitment_err_id;
  /**
   * @brief The natural log of the natural mortality for each year.
   */
  ParameterVector log_M;
  /**
   * @brief The population spawning biomass ratio for each year.
   */
  ParameterVector spawning_biomass_ratio;
  /**
   * @brief Log of the population annual fishing mortality multiplier.
   */
  ParameterVector log_f_multiplier;
  /**
   * @brief The natural log of the initial numbers at age.
   */
  ParameterVector log_init_naa;
  /**
   * @brief Ages that are modeled in the population, the length of this vector
   * should equal \"n_ages\".
   */
  RealVector ages;
  /**
   * @brief The name for the population.
   */
  SharedString name = fims::to_string("NA");

  /**
   * @brief The constructor.
   */
  PopulationInterface() : PopulationInterfaceBase() {
    this->fleet_ids = std::make_shared<std::set<uint32_t>>();
    std::shared_ptr<PopulationInterface> population =
        std::make_shared<PopulationInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(population);
    PopulationInterfaceBase::live_objects[this->id] = population;
  }

  /**
   * @brief Construct a new Population Interface object
   *
   * @param other
   */
  PopulationInterface(const PopulationInterface &other)
      : PopulationInterfaceBase(other),
        n_ages(other.n_ages),
        n_fleets(other.n_fleets),
        fleet_ids(other.fleet_ids),
        n_years(other.n_years),
        n_lengths(other.n_lengths),
        maturity_id(other.maturity_id),
        growth_id(other.growth_id),
        recruitment_id(other.recruitment_id),
        recruitment_err_id(other.recruitment_id),
        log_M(other.log_M),
        spawning_biomass_ratio(other.spawning_biomass_ratio),
        log_f_multiplier(other.log_f_multiplier),
        log_init_naa(other.log_init_naa),
        ages(other.ages),
        name(other.name) {}

  /**
   * @brief The destructor.
   */
  virtual ~PopulationInterface() {}

  /**
   * @brief Gets the ID of the interface base object.
   * @return The ID.
   */
  virtual uint32_t get_id() { return this->id; }

  /**
   * @brief Sets the name of the population.
   * @param name The name to set.
   */
  void SetName(const std::string &name) { this->name.set(name); }

  /**
   * @brief Gets the name of the population.
   * @return The name.
   */
  std::string GetName() const { return this->name.get(); }

  /**
   * @brief Sets the unique ID for the Maturity object.
   * @param maturity_id Unique ID for the Maturity object.
   */
  void SetMaturityID(uint32_t maturity_id) {
    this->maturity_id.set(maturity_id);
  }

  /**
   * @brief Set the unique ID for the growth object.
   * @param growth_id Unique ID for the growth object.
   */
  void SetGrowthID(uint32_t growth_id) { this->growth_id.set(growth_id); }

  /**
   * @brief Set the unique ID for the recruitment object.
   * @param recruitment_id Unique ID for the recruitment object.
   */
  void SetRecruitmentID(uint32_t recruitment_id) {
    this->recruitment_id.set(recruitment_id);
  }

  /**
   * @brief Add a fleet id to the list of fleets
   * operating on this population.
   */
  void AddFleet(uint32_t fleet_id) { this->fleet_ids->insert(fleet_id); }

  /**
   * @brief Extracts derived quantities back to the Rcpp interface object from
   * the Information object.
   */
  virtual void finalize() {
    if (this->finalized) {
      // log warning that finalize has been called more than once.
      FIMS_WARNING_LOG("Population " + fims::to_string(this->id) +
                       " has been finalized already.");
    }

    this->finalized = true;  // indicate this has been called already

    std::shared_ptr<fims_info::Information<double>> info =
        fims_info::Information<double>::GetInstance();

    fims_info::Information<double>::population_iterator it;

    it = info->populations.find(this->id);

    std::shared_ptr<fims_popdy::Population<double>> pop =
        info->populations[this->id];
    it = info->populations.find(this->id);
    if (it == info->populations.end()) {
      FIMS_WARNING_LOG("Population " + fims::to_string(this->id) +
                       " not found in Information.");
      return;
    } else {
      for (size_t i = 0; i < this->log_M.size(); i++) {
        if (this->log_M[i].estimation_type_m.get() == "constant") {
          this->log_M[i].final_value_m = this->log_M[i].initial_value_m;
        } else {
          this->log_M[i].final_value_m = pop->log_M[i];
        }
      }

      for (size_t i = 0; i < this->log_f_multiplier.size(); i++) {
        if (this->log_f_multiplier[i].estimation_type_m.get() == "constant") {
          this->log_f_multiplier[i].final_value_m =
              this->log_f_multiplier[i].initial_value_m;
        } else {
          this->log_f_multiplier[i].final_value_m = pop->log_f_multiplier[i];
        }
      }

      for (size_t i = 0; i < this->log_init_naa.size(); i++) {
        if (this->log_init_naa[i].estimation_type_m.get() == "constant") {
          this->log_init_naa[i].final_value_m =
              this->log_init_naa[i].initial_value_m;
        } else {
          this->log_init_naa[i].final_value_m = pop->log_init_naa[i];
        }
      }
    }
  }

#ifdef TMB_MODEL

  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();

    std::shared_ptr<fims_popdy::Population<Type>> population =
        std::make_shared<fims_popdy::Population<Type>>();

    std::stringstream ss;

    // set relative info
    population->id = this->id;
    population->n_years = this->n_years.get();
    population->n_fleets = this->n_fleets.get();
    // only define ages if n_ages greater than 0
    if (this->n_ages.get() > 0) {
      population->n_ages = this->n_ages.get();
      if (static_cast<size_t>(this->n_ages.get()) == this->ages.size()) {
        population->ages.resize(this->n_ages.get());
      } else {
        warning("The ages vector is not of size n_ages.");
      }
    }

    fleet_ids_iterator it;
    for (it = this->fleet_ids->begin(); it != this->fleet_ids->end(); it++) {
      population->fleet_ids.insert(*it);
    }

    population->growth_id = this->growth_id.get();
    population->recruitment_id = this->recruitment_id.get();
    population->maturity_id = this->maturity_id.get();
    population->log_M.resize(this->log_M.size());

    if (this->log_f_multiplier.size() ==
        static_cast<size_t>(this->n_years.get())) {
      population->log_f_multiplier.resize(this->log_f_multiplier.size());
    } else {
      FIMS_WARNING_LOG(
          "The log_f_multiplier vector is not of size n_years. Filling with "
          "zeros.");
      this->log_f_multiplier.resize((this->n_years.get()));
      for (size_t i = 0; i < log_f_multiplier.size(); i++) {
        this->log_f_multiplier[i].initial_value_m = static_cast<double>(0.0);
        this->log_f_multiplier[i].estimation_type_m.set("constant");
      }
      population->log_f_multiplier.resize(this->log_f_multiplier.size());
    }

    if (this->spawning_biomass_ratio.size() ==
        static_cast<size_t>(this->n_years.get() + 1)) {
      population->spawning_biomass_ratio.resize(
          this->spawning_biomass_ratio.size());
    } else {
      FIMS_WARNING_LOG(
          "Setting spawning_biomass_ratio vector to size n_years + 1.");
      this->spawning_biomass_ratio.resize((this->n_years.get() + 1));
      population->spawning_biomass_ratio.resize(
          this->spawning_biomass_ratio.size());
    }
    info->variable_map[this->spawning_biomass_ratio.id_m] =
        &(population)->spawning_biomass_ratio;

    population->log_init_naa.resize(this->log_init_naa.size());
    for (size_t i = 0; i < log_M.size(); i++) {
      population->log_M[i] = this->log_M[i].initial_value_m;
      if (this->log_M[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Population." << this->id << ".log_M." << this->log_M[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(population->log_M[i]);
      }
      if (this->log_M[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Population." << this->id << ".log_M." << this->log_M[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(population->log_M[i]);
      }
    }
    info->variable_map[this->log_M.id_m] = &(population)->log_M;

    for (size_t i = 0; i < log_f_multiplier.size(); i++) {
      population->log_f_multiplier[i] =
          this->log_f_multiplier[i].initial_value_m;
      if (this->log_f_multiplier[i].estimation_type_m.get() ==
          "fixed_effects") {
        ss.str("");
        ss << "Population." << this->id << ".log_f_multiplier."
           << this->log_f_multiplier[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(population->log_f_multiplier[i]);
      }
      if (this->log_f_multiplier[i].estimation_type_m.get() ==
          "random_effects") {
        ss.str("");
        ss << "Population." << this->id << ".log_f_multiplier."
           << this->log_f_multiplier[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(population->log_f_multiplier[i]);
      }
    }
    info->variable_map[this->log_f_multiplier.id_m] =
        &(population)->log_f_multiplier;

    for (size_t i = 0; i < log_init_naa.size(); i++) {
      population->log_init_naa[i] = this->log_init_naa[i].initial_value_m;
      if (this->log_init_naa[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Population." << this->id << ".log_init_naa."
           << this->log_init_naa[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(population->log_init_naa[i]);
      }
      if (this->log_init_naa[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Population." << this->id << ".log_init_naa."
           << this->log_init_naa[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(population->log_init_naa[i]);
      }
    }
    info->variable_map[this->log_init_naa.id_m] = &(population)->log_init_naa;

    for (size_t i = 0; i < ages.size(); i++) {
      population->ages[i] = this->ages[i];
    }

    // add to Information
    info->populations[population->id] = population;

    return true;
  }

  /**
   * @brief Adds the parameters to the TMB model.
   * @return A boolean of true.
   */
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();

    return true;
  }

#endif
};

#endif

/**
 * @file rcpp_recruitment.hpp
 * @brief The Rcpp interface to declare different types of recruitment, e.g.,
 * Beverton--Holt stock--recruitment relationship. Allows for the use of
 * methods::new() in R.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_RECRUITMENT_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_RECRUITMENT_HPP

#include "../../../population_dynamics/recruitment/recruitment.hpp"
#include "rcpp_interface_base.hpp"

/**
 * @brief Rcpp interface that serves as the parent class for Rcpp recruitment
 * interfaces. This type should be inherited and not called from R directly.
 */
class RecruitmentInterfaceBase : public FIMSRcppInterfaceBase {
 public:
  /**
   * @brief The static id of the RecruitmentInterfaceBase object.
   */
  static uint32_t id_g;
  /**
   * @brief The local id of the RecruitmentInterfaceBase object.
   */
  uint32_t id;
  /**
   * @brief The process id of the RecruitmentInterfaceBase object.
   */
  SharedInt process_id = -999;
  /**
   * @brief The map associating the IDs of RecruitmentInterfaceBase to the
   * objects. This is a live object, which is an object that has been created
   * and lives in memory.
   */
  static std::map<uint32_t, std::shared_ptr<RecruitmentInterfaceBase>>
      live_objects;

  /**
   * @brief The constructor.
   */
  RecruitmentInterfaceBase() {
    this->id = RecruitmentInterfaceBase::id_g++;
    /* Create instance of map: key is id and value is pointer to
    RecruitmentInterfaceBase */
    // RecruitmentInterfaceBase::live_objects[this->id] = this;
  }

  /**
   * @brief Construct a new Recruitment Interface Base object
   *
   * @param other
   */
  RecruitmentInterfaceBase(const RecruitmentInterfaceBase &other)
      : id(other.id), process_id(other.process_id) {}

  /**
   * @brief The destructor.
   */
  virtual ~RecruitmentInterfaceBase() {}

  /**
   * @brief Get the ID for the child recruitment interface objects to inherit.
   */
  virtual uint32_t get_id() = 0;

  /**
   * @brief A method for each child recruitment interface object to inherit so
   * each recruitment option can have an evaluate_mean() function.
   */
  virtual double evaluate_mean(double spawners, double ssbzero) = 0;

  /**
   * @brief A method for each child recruitment process interface object to
   * inherit so each recruitment process option can have a evaluate_process()
   * function.
   */
  virtual double evaluate_process(size_t pos) = 0;
};
// static id of the RecruitmentInterfaceBase object
uint32_t RecruitmentInterfaceBase::id_g = 1;
// local id of the RecruitmentInterfaceBase object map relating the ID of the
// RecruitmentInterfaceBase to the RecruitmentInterfaceBase objects
std::map<uint32_t, std::shared_ptr<RecruitmentInterfaceBase>>
    RecruitmentInterfaceBase::live_objects;

/**
 * @brief Rcpp interface for Beverton--Holt to instantiate from R:
 * beverton_holt <- methods::new(beverton_holt).
 */
class BevertonHoltRecruitmentInterface : public RecruitmentInterfaceBase {
 public:
  /**
   * @brief The number of years.
   */
  SharedInt n_years;
  /**
   * @brief The logistic transformation of steepness (h; productivity of the
   * population), where the parameter is transformed to constrain it between
   * 0.2 and 1.0.
   */
  ParameterVector logit_steep;
  /**
   * @brief The natural log of recruitment at unfished biomass.
   */
  ParameterVector log_rzero;
  /**
   * @brief The natural log of recruitment deviations.
   */
  ParameterVector log_devs;
  /**
   * @brief The recruitment random effect parameter on the natural log scale.
   */
  ParameterVector log_r;
  /**
   * @brief Expectation of the recruitment process.
   */
  ParameterVector log_expected_recruitment;
  /**
   * @brief The estimate of the logit transformation of steepness.
   */
  fims_double estimated_logit_steep;
  /**
   * @brief The estimate of the natural log of recruitment at unfished biomass.
   */
  fims_double estimated_log_rzero;
  /**
   * @brief The estimates of the natural log of recruitment deviations.
   */
  RealVector estimated_log_devs;

  /**
   * @brief The constructor.
   */
  BevertonHoltRecruitmentInterface() : RecruitmentInterfaceBase() {
    RecruitmentInterfaceBase::live_objects[this->id] =
        std::make_shared<BevertonHoltRecruitmentInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        RecruitmentInterfaceBase::live_objects[this->id]);
  }

  /**
   * @brief Construct a new Beverton--Holt Recruitment Interface object.
   *
   * @param other The passed object to copy.
   */
  BevertonHoltRecruitmentInterface(
      const BevertonHoltRecruitmentInterface &other)
      : RecruitmentInterfaceBase(other),
        n_years(other.n_years),
        logit_steep(other.logit_steep),
        log_rzero(other.log_rzero),
        log_devs(other.log_devs),
        log_r(other.log_r),
        log_expected_recruitment(other.log_expected_recruitment),
        estimated_logit_steep(other.estimated_logit_steep),
        estimated_log_rzero(other.estimated_log_rzero),
        estimated_log_devs(other.estimated_log_devs) {}

  /**
   * @brief The destructor.
   */
  virtual ~BevertonHoltRecruitmentInterface() {}

  /**
   * @brief Gets the ID of the interface base object.
   * @return The ID.
   */
  virtual uint32_t get_id() { return this->id; }

  /**
   * @brief Set the unique ID for the recruitment process object.
   * @param process_id Unique ID for the recruitment process object.
   */
  void SetRecruitmentProcessID(uint32_t process_id) {
    this->process_id.set(process_id);
  }

  /**
   * @brief Evaluate recruitment using the Beverton--Holt stock--recruitment
   * relationship.
   * @param spawners Spawning biomass per time step.
   * @param ssbzero The biomass at unfished levels.
   * TODO: Change to sbzero if continuing to use acronyms.
   */
  virtual double evaluate_mean(double spawners, double ssbzero) {
    fims_popdy::SRBevertonHolt<double> BevHolt;
    BevHolt.logit_steep.resize(1);
    BevHolt.logit_steep[0] = this->logit_steep[0].initial_value_m;
    if (this->logit_steep[0].initial_value_m == 1.0) {
      warning(
          "Steepness is subject to a logit transformation. "
          "Fixing it at 1.0 is not currently possible.");
    }
    BevHolt.log_rzero.resize(1);
    BevHolt.log_rzero[0] = this->log_rzero[0].initial_value_m;

    return BevHolt.evaluate_mean(spawners, ssbzero);
  }

  /**
   * @brief Evaluate recruitment process - returns 0 in this module.
   * @param pos Position index, e.g., which year.
   */
  virtual double evaluate_process(size_t pos) { return 0; }

  /**
   * @brief Extracts derived quantities back to the Rcpp interface object from
   * the Information object.
   */
  virtual void finalize() {
    if (this->finalized) {
      // log warning that finalize has been called more than once.
      FIMS_WARNING_LOG("Beverton-Holt Recruitment  " +
                       fims::to_string(this->id) +
                       " has been finalized already.");
    }

    this->finalized = true;  // indicate this has been called already

    std::shared_ptr<fims_info::Information<double>> info =
        fims_info::Information<double>::GetInstance();

    fims_info::Information<double>::recruitment_models_iterator it;

    it = info->recruitment_models.find(this->id);

    if (it == info->recruitment_models.end()) {
      FIMS_WARNING_LOG("Beverton-Holt Recruitment " +
                       fims::to_string(this->id) +
                       " not found in Information.");
      return;
    } else {
      std::shared_ptr<fims_popdy::SRBevertonHolt<double>> recr =
          std::dynamic_pointer_cast<fims_popdy::SRBevertonHolt<double>>(
              it->second);

      for (size_t i = 0; i < this->logit_steep.size(); i++) {
        if (this->logit_steep[i].estimation_type_m.get() == "constant") {
          this->logit_steep[i].final_value_m =
              this->logit_steep[i].initial_value_m;
        } else {
          this->logit_steep[i].final_value_m = recr->logit_steep[i];
        }
      }

      for (size_t i = 0; i < log_rzero.size(); i++) {
        if (log_rzero[i].estimation_type_m.get() == "constant") {
          this->log_rzero[i].final_value_m = this->log_rzero[i].initial_value_m;
        } else {
          this->log_rzero[i].final_value_m = recr->log_rzero[i];
        }
      }

      for (size_t i = 0; i < this->log_devs.size(); i++) {
        if (this->log_devs[i].estimation_type_m.get() == "constant") {
          this->log_devs[i].final_value_m = this->log_devs[i].initial_value_m;
        } else {
          this->log_devs[i].final_value_m = recr->log_recruit_devs[i];
        }
      }

      for (size_t i = 0; i < this->log_r.size(); i++) {
        if (this->log_r[i].estimation_type_m.get() == "constant") {
          this->log_r[i].final_value_m = this->log_r[i].initial_value_m;
        } else {
          this->log_r[i].final_value_m = recr->log_r[i];
        }
      }
    }
  }

  /**
   * @brief Converts the data to json representation for the output.
   * @return A string is returned specifying that the module relates to the
   * recruitment interface with Beverton--Holt stock--recruitment relationship.
   * It also returns the ID and the parameters. This string is formatted for a
   * json file.
   */
  virtual std::string to_json() {
    std::stringstream ss;

    ss << "{\n";
    ss << " \"module_name\": \"Recruitment\",\n";
    ss << " \"module_type\": \"Beverton-Holt\",\n";
    ss << " \"module_id\": " << this->id << ",\n";

    ss << " \"parameters\": [\n{\n";
    ss << "  \"name\": \"logit_steep\",\n";
    ss << "  \"id\":" << this->logit_steep.id_m << ",\n";
    ss << "  \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [" << this->logit_steep.size() << "]\n},\n";
    ss << "  \"values\":" << this->logit_steep << "},\n";

    ss << "{\n";
    ss << "   \"name\": \"log_rzero\",\n";
    ss << "   \"id\":" << this->log_rzero.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [" << this->log_rzero.size() << "]\n},\n";
    ss << "   \"values\":" << this->log_rzero << "},\n";

    ss << "{\n";
    ss << "   \"name\": \"log_devs\",\n";
    ss << "   \"id\":" << this->log_devs.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [\"n_years-1\"],\n";
    ss << "  \"dimensions\": [" << this->log_devs.size() << "]\n},\n";
    ss << "   \"values\":" << this->log_devs << "}]\n";
    ss << "}";
    return ss.str();
  }

#ifdef TMB_MODEL

  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();

    std::shared_ptr<fims_popdy::SRBevertonHolt<Type>> recruitment =
        std::make_shared<fims_popdy::SRBevertonHolt<Type>>();

    std::stringstream ss;

    // set relative info
    recruitment->id = this->id;
    recruitment->process_id = this->process_id.get();
    // set logit_steep
    recruitment->logit_steep.resize(this->logit_steep.size());
    for (size_t i = 0; i < this->logit_steep.size(); i++) {
      recruitment->logit_steep[i] = this->logit_steep[i].initial_value_m;

      if (this->logit_steep[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Recruitment." << this->id << ".logit_steep."
           << this->logit_steep[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(recruitment->logit_steep[i]);
      }
      if (this->logit_steep[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Recruitment." << this->id << ".logit_steep."
           << this->logit_steep[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(recruitment->logit_steep[i]);
      }
    }
    info->variable_map[this->logit_steep.id_m] = &(recruitment)->logit_steep;

    // set log_rzero
    recruitment->log_rzero.resize(this->log_rzero.size());
    for (size_t i = 0; i < this->log_rzero.size(); i++) {
      recruitment->log_rzero[i] = this->log_rzero[i].initial_value_m;

      if (this->log_rzero[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Recruitment." << this->id << ".log_rzero."
           << this->log_rzero[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(recruitment->log_rzero[i]);
      }
      if (this->log_rzero[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Recruitment." << this->id << ".log_rzero."
           << this->log_rzero[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(recruitment->log_rzero[i]);
      }
    }
    info->variable_map[this->log_rzero.id_m] = &(recruitment)->log_rzero;
    // set log_recruit_devs
    recruitment->log_recruit_devs.resize(this->log_devs.size());
    for (size_t i = 0; i < this->log_devs.size(); i++) {
      recruitment->log_recruit_devs[i] = this->log_devs[i].initial_value_m;

      if (this->log_devs[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Recruitment." << this->id << ".log_devs."
           << this->log_devs[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(recruitment->log_recruit_devs[i]);
      }
      if (this->log_devs[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Recruitment." << this->id << ".log_devs."
           << this->log_devs[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(recruitment->log_recruit_devs[i]);
      }
    }

    info->variable_map[this->log_devs.id_m] = &(recruitment)->log_recruit_devs;

    // set log_r
    recruitment->log_r.resize(this->log_r.size());
    for (size_t i = 0; i < log_r.size(); i++) {
      recruitment->log_r[i] = this->log_r[i].initial_value_m;

      if (this->log_r[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Recruitment." << this->id << ".log_r." << this->log_r[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(recruitment->log_r[i]);
      }
      if (this->log_r[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Recruitment." << this->id << ".log_r." << this->log_r[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(recruitment->log_r[i]);
      }
    }

    info->variable_map[this->log_r.id_m] = &(recruitment)->log_r;
    // set log_expected_recruitment
    recruitment->log_expected_recruitment.resize(this->n_years.get() + 1);
    for (size_t i = 0; i < static_cast<size_t>(this->n_years.get() + 1); i++) {
      recruitment->log_expected_recruitment[i] = 0;
    }
    info->variable_map[this->log_expected_recruitment.id_m] =
        &(recruitment)->log_expected_recruitment;

    // add to Information
    info->recruitment_models[recruitment->id] = recruitment;

    return true;
  }

  /**
   * @brief Adds the parameters to the TMB model.
   * @return A boolean of true.
   */
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();

    return true;
  }

#endif
};

/**
 * @brief Rcpp interface for Log--Devs to instantiate from R:
 * log_devs <- methods::new(log_devs).
 */
class LogDevsRecruitmentInterface : public RecruitmentInterfaceBase {
 public:
  /**
   * @brief The constructor.
   */
  LogDevsRecruitmentInterface() : RecruitmentInterfaceBase() {
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        std::make_shared<LogDevsRecruitmentInterface>(*this));
  }

  /**
   * @brief The destructor.
   */
  virtual ~LogDevsRecruitmentInterface() {}

  /**
   * @brief Gets the ID of the interface base object.
   * @return The ID.
   */
  virtual uint32_t get_id() { return this->id; }

  /**
   * @brief Evaluate mean - returns empty function for this module.
   * @param spawners Spawning biomass per time step.
   * @param ssbzero The biomass at unfished levels.
   */
  virtual double evaluate_mean(double spawners, double ssbzero) { return 0; }

  /**
   * @brief Evaluate recruitment process using the Log--Devs approach.
   * @param pos Position index, e.g., which year.
   */
  virtual double evaluate_process(size_t pos) {
    fims_popdy::LogDevs<double> LogDevs;

    return LogDevs.evaluate_process(pos);
  }

#ifdef TMB_MODEL

  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();

    std::shared_ptr<fims_popdy::LogDevs<Type>> recruitment_process =
        std::make_shared<fims_popdy::LogDevs<Type>>();

    recruitment_process->id = this->id;

    // add to Information
    info->recruitment_process_models[recruitment_process->id] =
        recruitment_process;

    return true;
  }

  /**
   * @brief Adds the parameters to the TMB model.
   * @return A boolean of true.
   */
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();

    return true;
  }

#endif
};

/**
 * @brief Rcpp interface for Log--R to instantiate from R:
 * log_r <- methods::new(log_r).
 */
class LogRRecruitmentInterface : public RecruitmentInterfaceBase {
 public:
  /**
   * @brief The constructor.
   */
  LogRRecruitmentInterface() : RecruitmentInterfaceBase() {
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        std::make_shared<LogRRecruitmentInterface>(*this));
  }

  /**
   * @brief The destructor.
   */
  virtual ~LogRRecruitmentInterface() {}

  /**
   * @brief Gets the ID of the interface base object.
   * @return The ID.
   */
  virtual uint32_t get_id() { return this->id; }

  /**
   * @brief Evaluate mean - returns empty function for this module.
   * @param spawners Spawning biomass per time step.
   * @param ssbzero The biomass at unfished levels.
   */
  virtual double evaluate_mean(double spawners, double ssbzero) { return 0; }

  /**
   * @brief Evaluate recruitment process using the Log--R approach.
   * @param pos Position index, e.g., which year.
   */
  virtual double evaluate_process(size_t pos) {
    fims_popdy::LogR<double> LogR;

    return LogR.evaluate_process(pos);
  }

#ifdef TMB_MODEL

  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();

    std::shared_ptr<fims_popdy::LogR<Type>> recruitment_process =
        std::make_shared<fims_popdy::LogR<Type>>();

    recruitment_process->id = this->id;

    // add to Information
    info->recruitment_process_models[recruitment_process->id] =
        recruitment_process;

    return true;
  }

  /**
   * @brief Adds the parameters to the TMB model.
   * @return A boolean of true.
   */
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();

    return true;
  }

#endif
};

#endif

/**
 * @file rcpp_selectivity.hpp
 * @brief The Rcpp interface to declare different types of selectivity, e.g.,
 * logistic and double logistic. Allows for the use of methods::new() in R.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_SELECTIVITY_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_SELECTIVITY_HPP

#include "../../../population_dynamics/selectivity/selectivity.hpp"
#include "rcpp_interface_base.hpp"

/**
 * @brief Rcpp interface that serves as the parent class for Rcpp selectivity
 * interfaces. This type should be inherited and not called from R directly.
 */
class SelectivityInterfaceBase : public FIMSRcppInterfaceBase {
 public:
  /**
   * @brief The static id of the SelectivityInterfaceBase.
   */
  static uint32_t id_g;
  /**
   * @brief The local id of the SelectivityInterfaceBase object.
   */
  uint32_t id;
  /**
   * @brief The map associating the IDs of SelectivityInterfaceBase to the
   * objects. This is a live object, which is an object that has been created
   * and lives in memory.
   */
  static std::map<uint32_t, std::shared_ptr<SelectivityInterfaceBase>>
      live_objects;

  /**
   * @brief The constructor.
   */
  SelectivityInterfaceBase() {
    this->id = SelectivityInterfaceBase::id_g++;
    /* Create instance of map: key is id and value is pointer to
    SelectivityInterfaceBase */
    // SelectivityInterfaceBase::live_objects[this->id] = this;
  }

  /**
   * @brief Construct a new Selectivity Interface Base object
   *
   * @param other
   */
  SelectivityInterfaceBase(const SelectivityInterfaceBase &other)
      : id(other.id) {}

  /**
   * @brief The destructor.
   */
  virtual ~SelectivityInterfaceBase() {}

  /**
   * @brief Get the ID for the child selectivity interface objects to inherit.
   */
  virtual uint32_t get_id() = 0;

  /**
   * @brief A method for each child selectivity interface object to inherit so
   * each selectivity option can have an evaluate() function.
   */
  virtual double evaluate(double x) = 0;
};
// static id of the SelectivityInterfaceBase object
uint32_t SelectivityInterfaceBase::id_g = 1;
// local id of the SelectivityInterfaceBase object map relating the ID of the
// SelectivityInterfaceBase to the SelectivityInterfaceBase objects
std::map<uint32_t, std::shared_ptr<SelectivityInterfaceBase>>
    SelectivityInterfaceBase::live_objects;

/**
 * @brief Rcpp interface for logistic selectivity to instantiate the object
 * from R:
 * logistic_selectivity <- methods::new(logistic_selectivity).
 */
class LogisticSelectivityInterface : public SelectivityInterfaceBase {
 public:
  /**
   * @brief The index value at which the response reaches 0.5.
   */
  ParameterVector inflection_point;
  /**
   * @brief The width of the curve at the inflection point.
   */
  ParameterVector slope;

  /**
   * @brief The constructor.
   */
  LogisticSelectivityInterface() : SelectivityInterfaceBase() {
    SelectivityInterfaceBase::live_objects[this->id] =
        std::make_shared<LogisticSelectivityInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        SelectivityInterfaceBase::live_objects[this->id]);
  }

  /**
   * @brief Construct a new Logistic Selectivity Interface object
   *
   * @param other
   */
  LogisticSelectivityInterface(const LogisticSelectivityInterface &other)
      : SelectivityInterfaceBase(other),
        inflection_point(other.inflection_point),
        slope(other.slope) {}

  /**
   * @brief The destructor.
   */
  virtual ~LogisticSelectivityInterface() {}

  /**
   * @brief Gets the ID of the interface base object.
   * @return The ID.
   */
  virtual uint32_t get_id() { return this->id; }

  /**
   * @brief Evaluate selectivity using the logistic function.
   * @param x The independent variable in the logistic function (e.g., age or
   * size in selectivity).
   */
  virtual double evaluate(double x) {
    fims_popdy::LogisticSelectivity<double> LogisticSel;
    LogisticSel.inflection_point.resize(1);
    LogisticSel.inflection_point[0] = this->inflection_point[0].initial_value_m;
    LogisticSel.slope.resize(1);
    LogisticSel.slope[0] = this->slope[0].initial_value_m;
    return LogisticSel.evaluate(x);
  }

  /**
   * @brief Extracts derived quantities back to the Rcpp interface object from
   * the Information object.
   */
  virtual void finalize() {
    if (this->finalized) {
      // log warning that finalize has been called more than once.
      FIMS_WARNING_LOG("Logistic Selectivity  " + fims::to_string(this->id) +
                       " has been finalized already.");
    }

    this->finalized = true;  // indicate this has been called already

    std::shared_ptr<fims_info::Information<double>> info =
        fims_info::Information<double>::GetInstance();

    fims_info::Information<double>::selectivity_models_iterator it;

    // search for maturity in Information
    it = info->selectivity_models.find(this->id);
    // if not found, just return
    if (it == info->selectivity_models.end()) {
      FIMS_WARNING_LOG("Logistic Selectivity " + fims::to_string(this->id) +
                       " not found in Information.");
      return;
    } else {
      std::shared_ptr<fims_popdy::LogisticSelectivity<double>> sel =
          std::dynamic_pointer_cast<fims_popdy::LogisticSelectivity<double>>(
              it->second);

      for (size_t i = 0; i < inflection_point.size(); i++) {
        if (this->inflection_point[i].estimation_type_m.get() == "constant") {
          this->inflection_point[i].final_value_m =
              this->inflection_point[i].initial_value_m;
        } else {
          this->inflection_point[i].final_value_m = sel->inflection_point[i];
        }
      }

      for (size_t i = 0; i < slope.size(); i++) {
        if (this->slope[i].estimation_type_m.get() == "constant") {
          this->slope[i].final_value_m = this->slope[i].initial_value_m;
        } else {
          this->slope[i].final_value_m = sel->slope[i];
        }
      }
    }
  }

  /**
   * @brief Converts the data to json representation for the output.
   * @return A string is returned specifying that the module relates to the
   * selectivity interface with logistic selectivity. It also returns the ID
   * and the parameters. This string is formatted for a json file.
   */
  virtual std::string to_json() {
    std::stringstream ss;

    ss << "{\n";
    ss << " \"module_name\":\"Selectivity\",\n";
    ss << " \"module_type\": \"Logistic\",\n";
    ss << " \"module_id\": " << this->id << ",\n";

    ss << " \"parameters\": [\n{\n";
    ss << "   \"name\": \"inflection_point\",\n";
    ss << "   \"id\":" << this->inflection_point.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [1]\n},\n";
    ss << "   \"values\":" << this->inflection_point << "},\n ";

    ss << "{\n";
    ss << "   \"name\": \"slope\",\n";
    ss << "   \"id\":" << this->slope.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [1]\n},\n";
    ss << "   \"values\":" << this->slope << "}]\n";

    ss << "}";

    return ss.str();
  }

#ifdef TMB_MODEL

  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();

    std::shared_ptr<fims_popdy::LogisticSelectivity<Type>> selectivity =
        std::make_shared<fims_popdy::LogisticSelectivity<Type>>();
    std::stringstream ss;
    // set relative info
    selectivity->id = this->id;
    selectivity->inflection_point.resize(this->inflection_point.size());
    for (size_t i = 0; i < this->inflection_point.size(); i++) {
      selectivity->inflection_point[i] =
          this->inflection_point[i].initial_value_m;
      if (this->inflection_point[i].estimation_type_m.get() ==
          "fixed_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".inflection_point."
           << this->inflection_point[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(selectivity->inflection_point[i]);
      }
      if (this->inflection_point[i].estimation_type_m.get() ==
          "random_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".inflection_point."
           << this->inflection_point[i].id_m;
        info->RegisterRandomEffect(selectivity->inflection_point[i]);
        info->RegisterRandomEffectName(ss.str());
      }
    }
    info->variable_map[this->inflection_point.id_m] =
        &(selectivity)->inflection_point;

    selectivity->slope.resize(this->slope.size());
    for (size_t i = 0; i < this->slope.size(); i++) {
      selectivity->slope[i] = this->slope[i].initial_value_m;
      if (this->slope[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".slope." << this->slope[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(selectivity->slope[i]);
      }
      if (this->slope[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".slope." << this->slope[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(selectivity->slope[i]);
      }
    }
    info->variable_map[this->slope.id_m] = &(selectivity)->slope;

    // add to Information
    info->selectivity_models[selectivity->id] = selectivity;

    return true;
  }

  /**
   * @brief Adds the parameters to the TMB model.
   * @return A boolean of true.
   */
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();

    return true;
  }

#endif
};

/**
 * @brief Rcpp interface for logistic selectivity as an S4 object. To
 * instantiate from R: logistic_selectivity <-
 * methods::new(logistic_selectivity)
 */
class DoubleLogisticSelectivityInterface : public SelectivityInterfaceBase {
 public:
  ParameterVector inflection_point_asc; /**< the index value at which the
                                     response reaches .5 */
  ParameterVector
      slope_asc; /**< the width of the curve at the inflection_point */
  ParameterVector inflection_point_desc; /**< the index value at which the
                                      response reaches .5 */
  ParameterVector
      slope_desc; /**< the width of the curve at the inflection_point */

  DoubleLogisticSelectivityInterface() : SelectivityInterfaceBase() {
    SelectivityInterfaceBase::live_objects[this->id] =
        std::make_shared<DoubleLogisticSelectivityInterface>(*this);
    FIMSRcppInterfaceBase::fims_interface_objects.push_back(
        SelectivityInterfaceBase::live_objects[this->id]);
  }

  /**
   * @brief Construct a new Double Logistic Selectivity Interface object
   *
   * @param other
   */
  DoubleLogisticSelectivityInterface(
      const DoubleLogisticSelectivityInterface &other)
      : SelectivityInterfaceBase(other),
        inflection_point_asc(other.inflection_point_asc),
        slope_asc(other.slope_asc),
        inflection_point_desc(other.inflection_point_desc),
        slope_desc(other.slope_desc) {}

  virtual ~DoubleLogisticSelectivityInterface() {}

  /** @brief returns the id for the double logistic selectivity interface */
  virtual uint32_t get_id() { return this->id; }

  /** @brief evaluate the double logistic selectivity function
   *   @param x  The independent variable in the logistic function (e.g., age or
   * size in selectivity).
   */
  virtual double evaluate(double x) {
    fims_popdy::DoubleLogisticSelectivity<double> DoubleLogisticSel;
    DoubleLogisticSel.inflection_point_asc.resize(1);
    DoubleLogisticSel.inflection_point_asc[0] =
        this->inflection_point_asc[0].initial_value_m;
    DoubleLogisticSel.slope_asc.resize(1);
    DoubleLogisticSel.slope_asc[0] = this->slope_asc[0].initial_value_m;
    DoubleLogisticSel.inflection_point_desc.resize(1);
    DoubleLogisticSel.inflection_point_desc[0] =
        this->inflection_point_desc[0].initial_value_m;
    DoubleLogisticSel.slope_desc.resize(1);
    DoubleLogisticSel.slope_desc[0] = this->slope_desc[0].initial_value_m;
    return DoubleLogisticSel.evaluate(x);
  }
  /**
   * @brief finalize function. Extracts derived quantities back to
   * the Rcpp interface object from the Information object.
   */
  virtual void finalize() {
    if (this->finalized) {
      // log warning that finalize has been called more than once.
      FIMS_WARNING_LOG("Double Logistic Selectivity  " +
                       fims::to_string(this->id) +
                       " has been finalized already.");
    }

    this->finalized = true;  // indicate this has been called already

    std::shared_ptr<fims_info::Information<double>> info =
        fims_info::Information<double>::GetInstance();

    fims_info::Information<double>::selectivity_models_iterator it;

    // search for maturity in Information
    it = info->selectivity_models.find(this->id);
    // if not found, just return
    if (it == info->selectivity_models.end()) {
      FIMS_WARNING_LOG("Double Logistic Selectivity " +
                       fims::to_string(this->id) +
                       " not found in Information.");
      return;
    } else {
      std::shared_ptr<fims_popdy::DoubleLogisticSelectivity<double>> sel =
          std::dynamic_pointer_cast<
              fims_popdy::DoubleLogisticSelectivity<double>>(it->second);

      for (size_t i = 0; i < inflection_point_asc.size(); i++) {
        if (this->inflection_point_asc[i].estimation_type_m.get() ==
            "constant") {
          this->inflection_point_asc[i].final_value_m =
              this->inflection_point_asc[i].initial_value_m;
        } else {
          this->inflection_point_asc[i].final_value_m =
              sel->inflection_point_asc[i];
        }
      }

      for (size_t i = 0; i < slope_asc.size(); i++) {
        if (this->slope_asc[i].estimation_type_m.get() == "constant") {
          this->slope_asc[i].final_value_m = this->slope_asc[i].initial_value_m;
        } else {
          this->slope_asc[i].final_value_m = sel->slope_asc[i];
        }
      }

      for (size_t i = 0; i < inflection_point_desc.size(); i++) {
        if (this->inflection_point_desc[i].estimation_type_m.get() ==
            "constant") {
          this->inflection_point_desc[i].final_value_m =
              this->inflection_point_desc[i].initial_value_m;
        } else {
          this->inflection_point_desc[i].final_value_m =
              sel->inflection_point_desc[i];
        }
      }

      for (size_t i = 0; i < slope_desc.size(); i++) {
        if (this->slope_desc[i].estimation_type_m.get() == "constant") {
          this->slope_desc[i].final_value_m =
              this->slope_desc[i].initial_value_m;
        } else {
          this->slope_desc[i].final_value_m = sel->slope_desc[i];
        }
      }
    }
  }

  /**
   * @brief Convert the data to json representation for the output.
   */
  virtual std::string to_json() {
    std::stringstream ss;

    ss << "{\n";
    ss << " \"module_name\": \"Selectivity\",\n";
    ss << " \"module_type\": \"DoubleLogistic\",\n";
    ss << " \"module_id\": " << this->id << ",\n";

    ss << " \"parameters\":[\n{\n";
    ss << "   \"name\": \"inflection_point_asc\",\n";
    ss << "   \"id\":" << this->inflection_point_asc.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [1]\n},\n";
    ss << "   \"values\":" << this->inflection_point_asc << "},\n";

    ss << "{\n";
    ss << "   \"name\": \"slope_asc\",\n";
    ss << "   \"id\":" << this->slope_asc.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [1]\n},\n";
    ss << "   \"values\":" << this->slope_asc << "},\n";

    ss << " {\n";
    ss << "   \"name\": \"inflection_point_desc\",\n";
    ss << "   \"id\":" << this->inflection_point_desc.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [1]\n},\n";
    ss << "   \"values\":" << this->inflection_point_desc << "},\n";

    ss << "{\n";
    ss << "   \"name\": \"slope_desc\",\n";
    ss << "   \"id\":" << this->slope_desc.id_m << ",\n";
    ss << "   \"type\": \"vector\",\n";
    ss << " \"dimensionality\": {\n";
    ss << "  \"header\": [null],\n";
    ss << "  \"dimensions\": [1]\n},\n";
    ss << "   \"values\":" << this->slope_desc << "}]\n";

    ss << "}";

    return ss.str();
  }

#ifdef TMB_MODEL

  template <typename Type>
  bool add_to_fims_tmb_internal() {
    std::shared_ptr<fims_info::Information<Type>> info =
        fims_info::Information<Type>::GetInstance();

    std::shared_ptr<fims_popdy::DoubleLogisticSelectivity<Type>> selectivity =
        std::make_shared<fims_popdy::DoubleLogisticSelectivity<Type>>();

    std::stringstream ss;
    // set relative info
    selectivity->id = this->id;
    selectivity->inflection_point_asc.resize(this->inflection_point_asc.size());
    for (size_t i = 0; i < this->inflection_point_asc.size(); i++) {
      selectivity->inflection_point_asc[i] =
          this->inflection_point_asc[i].initial_value_m;
      if (this->inflection_point_asc[i].estimation_type_m.get() ==
          "fixed_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".inflection_point_asc."
           << this->inflection_point_asc[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(selectivity->inflection_point_asc[i]);
      }
      if (this->inflection_point_asc[i].estimation_type_m.get() ==
          "random_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".inflection_point_asc."
           << this->inflection_point_asc[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(selectivity->inflection_point_asc[i]);
      }
    }
    info->variable_map[this->inflection_point_asc.id_m] =
        &(selectivity)->inflection_point_asc;

    selectivity->slope_asc.resize(this->slope_asc.size());
    for (size_t i = 0; i < this->slope_asc.size(); i++) {
      selectivity->slope_asc[i] = this->slope_asc[i].initial_value_m;

      if (this->slope_asc[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".slope_asc."
           << this->slope_asc[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(selectivity->slope_asc[i]);
      }
      if (this->slope_asc[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".slope_asc."
           << this->slope_asc[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(selectivity->slope_asc[i]);
      }
    }
    info->variable_map[this->slope_asc.id_m] = &(selectivity)->slope_asc;

    selectivity->inflection_point_desc.resize(
        this->inflection_point_desc.size());
    for (size_t i = 0; i < this->inflection_point_desc.size(); i++) {
      selectivity->inflection_point_desc[i] =
          this->inflection_point_desc[i].initial_value_m;

      if (this->inflection_point_desc[i].estimation_type_m.get() ==
          "fixed_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".inflection_point_desc."
           << this->inflection_point_desc[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(selectivity->inflection_point_desc[i]);
      }
      if (this->inflection_point_desc[i].estimation_type_m.get() ==
          "random_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".inflection_point_desc."
           << this->inflection_point_desc[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(selectivity->inflection_point_desc[i]);
      }
    }
    info->variable_map[this->inflection_point_desc.id_m] =
        &(selectivity)->inflection_point_desc;

    selectivity->slope_desc.resize(this->slope_desc.size());
    for (size_t i = 0; i < this->slope_desc.size(); i++) {
      selectivity->slope_desc[i] = this->slope_desc[i].initial_value_m;

      if (this->slope_desc[i].estimation_type_m.get() == "fixed_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".slope_desc."
           << this->slope_desc[i].id_m;
        info->RegisterParameterName(ss.str());
        info->RegisterParameter(selectivity->slope_desc[i]);
      }
      if (this->slope_desc[i].estimation_type_m.get() == "random_effects") {
        ss.str("");
        ss << "Selectivity." << this->id << ".slope_desc."
           << this->slope_desc[i].id_m;
        info->RegisterRandomEffectName(ss.str());
        info->RegisterRandomEffect(selectivity->slope_desc[i]);
      }
    }

    info->variable_map[this->slope_desc.id_m] = &(selectivity)->slope_desc;

    // add to Information
    info->selectivity_models[selectivity->id] = selectivity;

    return true;
  }

  /**
   * @brief Adds the parameters to the TMB model.
   * @return A boolean of true.
   */
  virtual bool add_to_fims_tmb() {
    this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
    this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();

    return true;
  }

#endif
};

#endif

/**
 * @file rcpp_shared_primitive.hpp
 * @brief Code to create shared pointers to allow for the wrapper functions
 * in R to work correctly so the live objects do not go out of scope.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_SHARED_PRIMITIVE_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_SHARED_PRIMITIVE_HPP

#include <memory>

/**
 * @class SharedInt
 * @brief A class that provides shared ownership of an integer value.
 *
 * @details This class wraps a `std::shared_ptr` to provide a reference-counted
 * integer value. When a `SharedInt` object is copied, it shares the same
 * underlying integer with the original object. The integer's memory is
 * automatically deallocated when the last `SharedInt` object pointing to it
 * is destroyed.
 */
class SharedInt {
 private:
  std::shared_ptr<int> value;

 public:
  /**
   * @brief Construct a new `SharedInt` object.
   *
   */
  SharedInt() : value(std::make_shared<int>(0)) {}

  /**
   * @brief Constructs a new `SharedInt` object.
   *
   * Initializes the object by creating a `std::shared_ptr` to an integer
   * with the provided value.
   *
   * @param val The integer value to be stored in the shared pointer.
   */
  SharedInt(int val) : value(std::make_shared<int>(val)) {}

  /**
   * @brief Copy constructs a new `SharedInt` object.
   *
   * Initializes the object by creating a new shared pointer that
   * shares ownership of the integer managed by another `SharedInt` object.
   *
   * @param other The existing `SharedInt` object to copy from.
   */
  SharedInt(const SharedInt& other) : value(other.value) {}

  /**
   * @brief Overloaded assignment operator for copying a `SharedInt` object.
   *
   * Assigns the shared state of `other` to the current object. If the object
   * is not self-assigned, it will share ownership of the same integer value.
   *
   * @param other The `SharedInt` object to assign from.
   * @return A reference to the current object (`*this`) to allow for chaining
   * assignments.
   */
  SharedInt& operator=(const SharedInt& other) {
    if (this != &other) {
      value = other.value;
    }
    return *this;
  }

  /**
   * @brief Overloaded assignment operator for an integer value.
   *
   * Assigns a new integer value to the underlying shared integer. This
   * operation modifies the shared state of the object.
   *
   * @param other The integer value to assign.
   * @return A reference to the current object (`*this`).
   */
  SharedInt& operator=(const int& other) {
    *value = other;

    return *this;
  }

  /**
   * @brief Constructs a new `SharedInt` object by moving resources.
   *
   * Transfers ownership of the shared integer from `other` to the new object.
   * This is a non-throwing operation that is more efficient than a copy.
   *
   * @param other The temporary `SharedInt` object to move from. After this
   * call, `other` will no longer own the resource.
   */
  SharedInt(SharedInt&& other) noexcept : value(std::move(other.value)) {}

  /**
   * @brief Overloaded move assignment operator.
   *
   * Moves the shared state from `other` to the current object, releasing any
   * resources the current object might have held. This is more efficient than a
   * copy operation.
   *
   * @param other The temporary `SharedInt` object to move from.
   * @return A reference to the current object (`*this`).
   */
  SharedInt& operator=(SharedInt&& other) noexcept {
    if (this != &other) {
      value = std::move(other.value);
    }
    return *this;
  }

  // Access the value

  /**
   * @brief Retrieve the value of the integer.
   *
   * @return int
   */
  int get() const { return *value; }

  /**
   * @brief Change the value of the integer
   *
   * @param val An integer value to set.
   */
  void set(int val) { *value = val; }

  /**
   * @brief User-defined conversion to `int`.
   *
   * @details This conversion operator allows the object to be implicitly
   * converted to an `int`. The returned value is the integer managed by the
   * object's internal shared pointer, which is retrieved by calling `get()`.
   *
   * @return The integer value held by the object.
   */
  operator int() { return this->get(); }

  // Overloaded operators for SharedPrimitive

  /**
   * @brief Overloads the dereference operator.
   *
   * @details Provides a convenient way to access the integer value held by the
   * shared pointer. This function is `const`, meaning it provides read-only
   * access and does not modify the object's state.
   *
   * @return The integer value managed by the shared pointer.
   */
  int operator*() const { return *value; }

  /**
   * @brief Overloads the member access operator (`->`).
   *
   * @details Provides a way to access the integer value by returning a raw
   * pointer to it. This function returns the result of
   * `std::shared_ptr::get()`.
   *
   * @return A raw pointer (`int*`) to the integer managed by the shared
   * pointer.
   */
  int* operator->() { return value.get(); }

  /**
   * @brief Overloads the member access operator (`->`) for const objects.
   *
   * @details This function provides a way to get a read-only raw pointer to the
   * underlying integer. The `const` return type prevents modification of the
   * integer value through this pointer. The function itself is also `const`,
   * ensuring it can be called on `const` instances of the class.
   *
   * @return A `const` raw pointer to the integer managed by the shared pointer.
   */
  const int* operator->() const { return value.get(); }

  // Unary operators

  /**
   * @brief Overloads the prefix increment operator (`++`).
   *
   * @details Increments the integer value managed by the shared pointer. As a
   * prefix operator, it increments the value *before* returning the result.
   *
   * @return A reference to the current object (`*this`) after the increment
   * has occurred.
   */
  SharedInt& operator++() {
    ++(*value);
    return *this;
  }

  /**
   * @brief Overloads the postfix increment operator (`++`).
   *
   * @details This is a postfix operation. It first creates a copy of the
   * object's current state, then increments the underlying integer value, and
   * finally returns the temporary copy, which holds the original value.
   * A dummy parameter used by the compiler to distinguish this
   * operator from the prefix version.
   * @return A copy of the object's state *before* the increment occurred.
   */
  SharedInt operator++(int) {
    SharedInt temp(*this);
    ++(*value);
    return temp;
  }

  /**
   * @brief Overloads the prefix decrement operator (`--`).
   *
   * @details Decrements the integer value managed by the shared pointer. As a
   * prefix operator, it decrements the value *before* returning the result.
   *
   * @return A reference to the current object (`*this`) after the decrement
   * has occurred.
   */
  SharedInt& operator--() {
    --(*value);
    return *this;
  }

  /**
   * @brief Overloads the postfix decrement operator.
   *
   * @details This is a postfix operation. It first creates a copy of the
   * object's current state, then decrements the underlying integer value, and
   * finally returns the temporary copy, which holds the original value.
   * A dummy parameter used by the compiler to distinguish this
   * operator from the prefix version.
   * @return A copy of the object's state *before* the decrement occurred.
   */
  SharedInt operator--(int) {
    SharedInt temp(*this);
    --(*value);
    return temp;
  }

  // Arithmetic operators with SharedPrimitive

  /**
   * @brief Overloads the binary addition operator (`+`).
   *
   * @details Adds the integer value of the current object to the integer value
   * of the `other` object. This operation does not modify either object; it
   * returns a new `SharedInt` object containing the sum.
   *
   * @param other The `SharedInt` object to add to the current object.
   * @return A new `SharedInt` object containing the sum of the two values.
   */
  SharedInt operator+(const SharedInt& other) const {
    return SharedInt(*value + *other.value);
  }

  /**
   * @brief Overloads the binary subtraction operator (`-`).
   *
   * @details Subtracts the integer value of the current object to the integer
   * value of the `other` object. This operation does not modify either object;
   * it returns a new `SharedInt` object containing the difference.
   *
   * @param other The `SharedInt` object to subtract from the current object.
   * @return A new `SharedInt` object containing the difference of the two
   * values.
   */
  SharedInt operator-(const SharedInt& other) const {
    return SharedInt(*value - *other.value);
  }

  /**
   * @brief Overloads the binary multiplication operator (`*`).
   *
   * @details Multiplies the integer value of the current object by the integer
   * value of the `other` object. This operation does not modify either object;
   * it returns a new `SharedInt` object containing the product.
   *
   * @param other The `SharedInt` object to multiply the current object by.
   * @return A new `SharedInt` object containing the product of the two values.
   */
  SharedInt operator*(const SharedInt& other) const {
    return SharedInt(*value * *other.value);
  }

  /**
   * @brief Overloads the binary division operator (`/`).
   *
   * @details Divides the integer value of the current object by the integer
   * value of the `other` object. This operation does not modify either object;
   * it returns a new `SharedInt` object containing the result of the division.
   *
   * @param other The `SharedInt` object to divide the current object by.
   * @return A new `SharedInt` object containing the quotient of the two values.
   */
  SharedInt operator/(const SharedInt& other) const {
    return SharedInt(*value / *other.value);
  }

  // Arithmetic operators with primitives

  /**
   * @brief Overloads the binary addition operator for an integer value.
   *
   * @details Adds an integer value to the integer value of the current object.
   * This operation does not modify the current object; it returns a new
   * `SharedInt` object containing the sum.
   *
   * @param other The integer value to add to the current object.
   * @return A new `SharedInt` object containing the sum of the two values.
   */
  SharedInt operator+(const int& other) const {
    return SharedInt(*value + other);
  }

  /**
   * @brief Overloads the binary subtraction operator for an integer value.
   *
   * @details Subtracts an integer value from the integer value of the current
   * object. This operation does not modify the current object; it returns a
   * new `SharedInt` object containing the result.
   *
   * @param other The integer value to subtract from the current object.
   * @return A new `SharedInt` object containing the result of the subtraction.
   */
  SharedInt operator-(const int& other) const {
    return SharedInt(*value - other);
  }

  /**
   * @brief Overloads the binary multiplication operator for an integer value.
   *
   * @details Multiplies the integer value of the current object by the integer
   * value of `other`. This operation does not modify the current object; it
   * returns a new `SharedInt` object containing the product.
   *
   * @param other The integer value to multiply the current object by.
   * @return A new `SharedInt` object containing the product of the two values.
   */
  SharedInt operator*(const int& other) const {
    return SharedInt(*value * other);
  }

  /**
   * @brief Overloads the binary division operator for an integer value.
   *
   * @details Divides the integer value of the current object by the integer
   * value of `other`. This operation does not modify the current object; it
   * returns a new `SharedInt` object containing the quotient.
   *
   * @param other The integer value to divide the current object by.
   * @return A new `SharedInt` object containing the quotient of the two values.
   */
  SharedInt operator/(const int& other) const {
    return SharedInt(*value / other);
  }

  // Compound assignment operators with SharedPrimitive

  /**
   * @brief Overloads the compound assignment operator (`+=`).
   *
   * @details Adds the integer value of `other` to the current object's value,
   * modifying the object in place.
   *
   * @param other The `SharedInt` object to add.
   * @return A reference to the current object (`*this`) after the addition.
   */
  SharedInt& operator+=(const SharedInt& other) {
    *value += *other.value;
    return *this;
  }

  /**
   * @brief Overloads the compound assignment operator (`-=`).
   *
   * @details Subtracts the integer value of `other` from the current object's
   * value, modifying the object in place.
   *
   * @param other The `SharedInt` object to subtract.
   * @return A reference to the current object (`*this`) after the subtraction.
   */
  SharedInt& operator-=(const SharedInt& other) {
    *value -= *other.value;
    return *this;
  }

  /**
   * @brief Overloads the compound assignment operator (`*=`).
   *
   * @details Multiplies the integer value of the current object by the value
   * of `other`, modifying the object in place.
   *
   * @param other The `SharedInt` object to multiply by.
   * @return A reference to the current object (`*this`) after the
   * multiplication.
   */
  SharedInt& operator*=(const SharedInt& other) {
    *value *= *other.value;
    return *this;
  }

  /**
   * @brief Overloads the compound assignment operator (`/=`).
   *
   * @details Divides the integer value of the current object by the value
   * of `other`, modifying the object in place.
   *
   * @param other The `SharedInt` object to divide by.
   * @return A reference to the current object (`*this`) after the division.
   */
  SharedInt& operator/=(const SharedInt& other) {
    *value /= *other.value;
    return *this;
  }

  // Compound assignment operators with primitives

  /**
   * @brief Overloads the compound assignment operator (`+=`) for a shared
   * integer value.
   *
   * @details Adds an integer value to the current object's value, modifying the
   * object in place.
   *
   * @param other The integer value to add to the current object.
   * @return A reference to the current object (`*this`) after the addition.
   */
  SharedInt& operator+=(const int& other) {
    *value += other;
    return *this;
  }

  /**
   * @brief Overloads the compound assignment operator (`-=`) for a shared
   * integer value.
   *
   * @details Subtracts an integer value from the current object's value,
   * modifying the object in place.
   *
   * @param other The integer value to subtract from the current object.
   * @return A reference to the current object (`*this`) after the subtraction.
   */
  SharedInt& operator-=(const int& other) {
    *value -= other;
    return *this;
  }

  /**
   * @brief Overloads the compound assignment operator (`*=`) for a shared
   * integer value.
   *
   * @details Multiplies the integer value of the current object by the integer
   * value of `other`, modifying the object in place.
   *
   * @param other The integer value to multiply the current object by.
   * @return A reference to the current object (`*this`) after the
   * multiplication.
   */
  SharedInt& operator*=(const int& other) {
    *value *= other;
    return *this;
  }

  /**
   * @brief Overloads the compound assignment operator (`/=`) for a shared
   * integer value.
   *
   * @details Divides the integer value of the current object by the integer
   * value of `other`, modifying the object in place.
   *
   * @param other The integer value to divide the current object by.
   * @return A reference to the current object (`*this`) after the division.
   */
  SharedInt& operator/=(const int& other) {
    *value /= other;
    return *this;
  }

  // Relational operators

  /**
   * @brief Overloads the equality operator (`==`).
   *
   * @details Compares the integer value of the current object with the integer
   * value of `other` for equality. This is a non-mutating operation.
   *
   * @param other The `SharedInt` object to compare against.
   * @return `true` if the values are equal, `false` otherwise.
   */
  bool operator==(const SharedInt& other) const {
    return *value == *other.value;
  }

  /**
   * @brief Overloads the inequality operator (`!=`).
   *
   * @details Compares the integer value of the current object with the integer
   * value of `other` for inequality. This is a non-mutating operation.
   *
   * @param other The `SharedInt` object to compare against.
   * @return `true` if the values are not equal, `false` otherwise.
   */
  bool operator!=(const SharedInt& other) const {
    return *value != *other.value;
  }

  /**
   * @brief Overloads the less-than operator (`<`).
   *
   * @details Compares the integer value of the current object with the integer
   * value of `other`. This is a non-mutating operation.
   *
   * @param other The `SharedInt` object to compare against.
   * @return `true` if the current object's value is less than `other`'s value,
   * `false` otherwise.
   */
  bool operator<(const SharedInt& other) const { return *value < *other.value; }

  /**
   * @brief Overloads the less-than-or-equal-to operator (`<=`).
   *
   * @details Compares the integer value of the current object with the integer
   * value of `other`. This is a non-mutating operation.
   *
   * @param other The `SharedInt` object to compare against.
   * @return `true` if the current object's value is less than or equal to
   * `other`'s value, `false` otherwise.
   */
  bool operator<=(const SharedInt& other) const {
    return *value <= *other.value;
  }

  /**
   * @brief Overloads the greater-than operator (`>`).
   *
   * @details Compares the integer value of the current object with the integer
   * value of `other`. This is a non-mutating operation.
   *
   * @param other The `SharedInt` object to compare against.
   * @return `true` if the current object's value is greater than `other`'s
   * value, `false` otherwise.
   */
  bool operator>(const SharedInt& other) const { return *value > *other.value; }

  /**
   * @brief Overloads the greater-than-or-equal-to operator (`>=`).
   *
   * @details Compares the integer value of the current object with the integer
   * value of `other`. This is a non-mutating operation.
   *
   * @param other The `SharedInt` object to compare against.
   * @return `true` if the current object's value is greater than or equal to
   * `other`'s value, `false` otherwise.
   */
  bool operator>=(const SharedInt& other) const {
    return *value >= *other.value;
  }

  // Relational operators with primitives

  /**
   * @brief Overloads the equality operator (`==`) for an integer value.
   *
   * @details Compares the integer value of the current object with an `int`
   * for equality. This is a non-mutating operation.
   *
   * @param other The integer value to compare against.
   * @return `true` if the values are equal, `false` otherwise.
   */
  bool operator==(const int& other) const { return *value == other; }

  /**
   * @brief Overloads the inequality operator (`!=`) for an integer value.
   *
   * @details Compares the integer value of the current object with an `int`
   * for inequality. This is a non-mutating operation.
   *
   * @param other The integer value to compare against.
   * @return `true` if the values are not equal, `false` otherwise.
   */
  bool operator!=(const int& other) const { return *value != other; }

  /**
   * @brief Overloads the less-than operator (`<`) for an integer value.
   *
   * @details Compares the integer value of the current object with an `int`.
   * This is a non-mutating operation.
   *
   * @param other The integer value to compare against.
   * @return `true` if the current object's value is less than `other`, `false`
   * otherwise.
   */
  bool operator<(const int& other) const { return *value < other; }

  /**
   * @brief Overloads the less-than-or-equal-to operator (`<=`) for an integer
   * value.
   *
   * @details Compares the integer value of the current object with an `int`.
   * This is a non-mutating operation.
   *
   * @param other The integer value to compare against.
   * @return `true` if the current object's value is less than or equal to
   * `other`, `false` otherwise.
   */
  bool operator<=(const int& other) const { return *value <= other; }

  /**
   * @brief Overloads the greater-than operator (`>`) for an integer value.
   *
   * @details Compares the integer value of the current object with an `int`.
   * This is a non-mutating operation.
   *
   * @param other The integer value to compare against.
   * @return `true` if the current object's value is greater than `other`,
   * `false` otherwise.
   */
  bool operator>(const int& other) const { return *value > other; }

  /**
   * @brief Overloads the greater-than-or-equal-to operator (`>=`) for an
   * integer value.
   *
   * @details Compares the integer value of the current object with an `int`.
   * This is a non-mutating operation.
   *
   * @param other The integer value to compare against.
   * @return `true` if the current object's value is greater than or equal to
   * `other`, `false` otherwise.
   */
  bool operator>=(const int& other) const { return *value >= other; }

  /**
   * @brief Overloads the stream insertion operator (`<<`) for `SharedInt`.
   *
   * @details Provides a way to print the integer value of a `SharedInt` object
   * to an output stream.
   *
   * @param os The output stream to write to.
   * @param sp The `SharedInt` object to print.
   * @return A reference to the output stream, allowing for chained insertions.
   */
  friend std::ostream& operator<<(std::ostream& os, const SharedInt& sp) {
    os << *sp.value;
    return os;
  }
};

// Non-member operators for primitive + SharedPrimitive

/**
 * @brief Overloads the binary addition operator (`+`) for an integer
 * left-hand side operand.
 *
 * @details Adds an integer to a `SharedInt`'s value, returning a new
 * `SharedInt` object with the result. This enables expressions
 * like `5 + my_shared_int`.
 *
 * @param lhs The integer value on the left-hand side of the operator.
 * @param rhs The `SharedInt` object on the right-hand side.
 * @return A new `SharedInt` object containing the sum.
 */
SharedInt operator+(const int& lhs, const SharedInt& rhs) {
  return SharedInt(lhs + rhs.get());
}

/**
 * @brief Overloads the binary subtraction operator (`-`) for an integer
 * left-hand side operand.
 *
 * @details Subtracts a `SharedInt`'s value from an integer, returning a
 * new `SharedInt` object with the result. This enables expressions
 * like `10 - my_shared_int`.
 *
 * @param lhs The integer value on the left-hand side of the operator.
 * @param rhs The `SharedInt` object on the right-hand side.
 * @return A new `SharedInt` object containing the result of the subtraction.
 */
SharedInt operator-(const int& lhs, const SharedInt& rhs) {
  return SharedInt(lhs - rhs.get());
}

/**
 * @brief Overloads the binary multiplication operator (`*`) for an
 * integer left-hand side operand.
 *
 * @details Multiplies an integer by a `SharedInt`'s value, returning a
 * new `SharedInt` object with the product.
 *
 * @param lhs The integer value on the left-hand side of the operator.
 * @param rhs The `SharedInt` object on the right-hand side.
 * @return A new `SharedInt` object containing the product.
 */
SharedInt operator*(const int& lhs, const SharedInt& rhs) {
  return SharedInt(lhs * rhs.get());
}

/**
 * @brief Overloads the binary division operator (`/`) for an integer
 * left-hand side operand.
 *
 * @details Divides an integer by a `SharedInt`'s value, returning a new
 * `SharedInt` object with the quotient.
 *
 * @param lhs The integer value on the left-hand side of the operator.
 * @param rhs The `SharedInt` object on the right-hand side.
 * @return A new `SharedInt` object containing the quotient.
 */
SharedInt operator/(const int& lhs, const SharedInt& rhs) {
  return SharedInt(lhs / rhs.get());
}

/**
 * @brief Overloads the less-than operator (`<`) for an integer
 * left-hand side operand.
 *
 * @details Compares an integer to a `SharedInt`'s value.
 *
 * @param lhs The integer value on the left-hand side of the operator.
 * @param rhs The `SharedInt` object on the right-hand side.
 * @return `true` if the integer is less than the `SharedInt`'s value,
 * `false` otherwise.
 */
bool operator<(const int& lhs, const SharedInt& rhs) {
  return (lhs < rhs.get());
}

/**
 * @brief Overloads the less-than-or-equal-to operator (`<=`) for an
 * integer left-hand side operand.
 *
 * @details Compares an integer to a `SharedInt`'s value.
 *
 * @param lhs The integer value on the left-hand side of the operator.
 * @param rhs The `SharedInt` object on the right-hand side.
 * @return `true` if the integer is less than or equal to the `SharedInt`'s
 * value, `false` otherwise.
 */
bool operator<=(const int& lhs, const SharedInt& rhs) {
  return (lhs <= rhs.get());
}

/**
 * @brief Overloads the greater-than operator (`>`) for an integer
 * left-hand side operand.
 *
 * @details Compares an integer to a `SharedInt`'s value.
 *
 * @param lhs The integer value on the left-hand side of the operator.
 * @param rhs The `SharedInt` object on the right-hand side.
 * @return `true` if the integer is greater than the `SharedInt`'s value,
 * `false` otherwise.
 */
bool operator>(const int& lhs, const SharedInt& rhs) {
  return (lhs > rhs.get());
}

/**
 * @brief Overloads the greater-than-or-equal-to operator (`>=`) for an
 * integer left-hand side operand.
 *
 * @details Compares an integer to a `SharedInt`'s value.
 *
 * @param lhs The integer value on the left-hand side of the operator.
 * @param rhs The `SharedInt` object on the right-hand side.
 * @return `true` if the integer is greater than or equal to the
 * `SharedInt`'s value, `false` otherwise.
 */
bool operator>=(const int& lhs, const SharedInt& rhs) {
  return (lhs >= rhs.get());
}

/**
 * @class SharedReal
 * @brief A class that provides shared ownership of an integer value.
 *
 * @details This class wraps a `std::shared_ptr` to provide a reference-counted
 * integer value. When a SharedReal object is copied, it shares the same
 * underlying integer with the original object. The integer's memory is
 * automatically deallocated when the last SharedReal object pointing to it
 * is destroyed.
 */
class SharedReal {
 private:
  std::shared_ptr<int> value;

 public:
  /**
   * @brief Constructs a new `SharedReal` object with a default value.
   *
   * @details Initializes the object's internal shared pointer to manage a new
   * integer with a value of zero.
   */
  SharedReal() : value(std::make_shared<int>(0)) {}

  /**
   * @brief Constructs a new `SharedReal` object from an integer value.
   *
   * @details Initializes the object's internal shared pointer to manage a new
   * integer with the value provided by the `val` parameter.
   *
   * @param val The integer value to be stored in the shared pointer.
   */
  SharedReal(int val) : value(std::make_shared<int>(val)) {}

  /**
   * @brief Copy constructs a new `SharedReal` object.
   *
   * @details Initializes the object by creating a new shared pointer that
   * shares ownership of the integer managed by another `SharedReal` object.
   *
   * @param other The existing `SharedReal` object to copy from.
   */
  SharedReal(const SharedReal& other) : value(other.value) {}

  /**
   * @brief Overloaded copy assignment operator.
   *
   * @details Assigns the shared state of `other` to the current object. If the
   * objects are not the same, the current object will release its old resource
   * and share ownership of the integer value managed by `other`.
   *
   * @param other The `SharedReal` object to assign from.
   * @return A reference to the current object (`*this`) to allow for chained
   * assignments.
   */
  SharedReal& operator=(const SharedReal& other) {
    if (this != &other) {
      value = other.value;
    }
    return *this;
  }

  /**
   * @brief Overloaded assignment operator for an integer value.
   *
   * @details Assigns a new integer value to the underlying shared integer,
   * modifying the object in place.
   *
   * @param other The integer value to assign.
   * @return A reference to the current object (`*this`) to allow for
   * chained assignments.
   */
  SharedReal& operator=(const int& other) {
    *value = other;

    return *this;
  }

  /**
   * @brief Constructs a new `SharedReal` object by moving resources.
   *
   * @details Transfers ownership of the shared integer from `other` to the new
   * object. This is a non-throwing operation that is more efficient than a
   * copy and is also known as a move constructor.
   *
   * @param other The temporary `SharedReal` object to move from. After this
   * call, `other` will no longer own the resource.
   */
  SharedReal(SharedReal&& other) noexcept : value(std::move(other.value)) {}

  /**
   * @brief Overloaded move assignment operator.
   *
   * @details Moves the shared state from `other` to the current object,
   * releasing any resources the current object might have held. This is a
   * non-throwing and more efficient operation than a copy assignment and is
   * also known as a move assignment operator.
   *
   * @param other The temporary `SharedReal` object to move from.
   * @return A reference to the current object (`*this`).
   */
  SharedReal& operator=(SharedReal&& other) noexcept {
    if (this != &other) {
      value = std::move(other.value);
    }
    return *this;
  }

  /**
   * @brief Retrieves the integer value managed by the object.
   *
   * @details This is a getter function that returns a copy of the integer
   * value. Since the function is `const`, it can be safely called on a constant
   * instance of the class without modifying its state.
   *
   * @return The integer value managed by the shared pointer.
   */
  int get() const { return *value; }

  /**
   * @brief Sets the integer value of the object.
   *
   * @details Assigns a new integer value to the underlying shared integer.
   *
   * @param val The integer value to set.
   */
  void set(int val) { *value = val; }

  /**
   * @brief User-defined conversion to `int`.
   *
   * @details This conversion operator allows the object to be implicitly
   * converted to an `int`. The returned value is the integer managed by the
   * object's internal shared pointer, which is retrieved by calling `get()`.
   *
   * @return The integer value held by the object.
   */
  operator int() { return this->get(); }

  // Overloaded operators for SharedPrimitive

  /**
   * @brief Overloads the dereference operator (`*`).
   *
   * @details Provides direct access to the integer value managed by the
   * internal shared pointer. This function is `const` and provides a
   * read-only view of the data.
   *
   * @return The integer value held by the object.
   */
  int operator*() const { return *value; }

  /**
   * @brief Overloads the member access operator (`->`).
   *
   * @details This function provides a way to access the underlying integer
   * value by returning a raw pointer to it. It returns the result of the
   * `std::shared_ptr::get()` method.
   *
   * @return A raw pointer (`int*`) to the integer managed by the shared
   * pointer.
   */
  int* operator->() { return value.get(); }

  /**
   * @brief Overloads the member access operator (`->`) for const objects.
   *
   * @details This function provides a way to get a read-only raw pointer to the
   * underlying integer. The `const` return type prevents modification of the
   * integer value through this pointer. The function itself is also `const`,
   * ensuring it can be called on `const` instances of the class.
   *
   * @return A `const` raw pointer to the integer managed by the shared pointer.
   */
  const int* operator->() const { return value.get(); }

  // Unary operators

  /**
   * @brief Overloads the prefix increment operator (`++`).
   *
   * @details Increments the integer value managed by the shared pointer. As a
   * prefix operator, it increments the value *before* returning the result.
   *
   * @return A reference to the current object (`*this`) after the increment has
   * occurred.
   */
  SharedReal& operator++() {
    ++(*value);
    return *this;
  }

  /**
   * @brief Overloads the postfix increment operator.
   *
   * @details This is a postfix operation. It first creates a copy of the
   * object's current state, then increments the underlying integer value, and
   * finally returns the temporary copy, which holds the original value.
   * A dummy parameter used by the compiler to distinguish this
   * operator from the prefix version.
   * @return A copy of the object's state *before* the increment occurred.
   */
  SharedReal operator++(int) {
    SharedReal temp(*this);
    ++(*value);
    return temp;
  }

  /**
   * @brief Overloads the prefix decrement operator (`--`).
   *
   * @details Decrements the integer value managed by the shared pointer.
   * As a prefix operator, it decrements the value *before* returning the
   * result.
   *
   * @return A reference to the current object (`*this`) after the decrement has
   * occurred.
   */
  SharedReal& operator--() {
    --(*value);
    return *this;
  }

  /**
   * @brief Overloads the postfix decrement operator.
   *
   * @details This is a postfix operation. It first creates a copy of the
   * object's current state, then decrements the underlying integer value, and
   * finally returns the temporary copy, which holds the original value.
   * A dummy parameter used by the compiler to distinguish this
   * operator from the prefix version.
   * @return A copy of the object's state *before* the decrement occurred.
   */
  SharedReal operator--(int) {
    SharedReal temp(*this);
    --(*value);
    return temp;
  }

  // Arithmetic operators with SharedPrimitive

  /**
   * @brief Overloads the binary addition operator (`+`).
   *
   * @details Adds the integer value of the current object to the integer
   * value of `other`. This operation does not modify either object; it
   * returns a new `SharedReal` object containing the sum.
   *
   * @param other The `SharedReal` object to add to the current object.
   * @return A new `SharedReal` object containing the sum of the two values.
   */
  SharedReal operator+(const SharedReal& other) const {
    return SharedReal(*value + *other.value);
  }

  /**
   * @brief Overloads the binary subtraction operator (`-`).
   *
   * @details Subtracts the integer value of `other` from the current
   * object's value. This operation does not modify either object; it
   * returns a new `SharedReal` object containing the result.
   *
   * @param other The `SharedReal` object to subtract from the current
   * object.
   * @return A new `SharedReal` object containing the result of the
   * subtraction.
   */
  SharedReal operator-(const SharedReal& other) const {
    return SharedReal(*value - *other.value);
  }

  /**
   * @brief Overloads the binary multiplication operator (`*`).
   *
   * @details Multiplies the integer value of the current object by the
   * integer value of `other`. This operation does not modify either
   * object; it returns a new `SharedReal` object containing the product.
   *
   * @param other The `SharedReal` object to multiply by.
   * @return A new `SharedReal` object containing the product of the two
   * values.
   */
  SharedReal operator*(const SharedReal& other) const {
    return SharedReal(*value * *other.value);
  }

  /**
   * @brief Overloads the binary division operator (`/`).
   *
   * @details Divides the integer value of the current object by the
   * integer value of `other`. This operation does not modify either
   * object; it returns a new `SharedReal` object containing the quotient.
   *
   * @param other The `SharedReal` object to divide by.
   * @return A new `SharedReal` object containing the quotient of the two
   * values.
   */
  SharedReal operator/(const SharedReal& other) const {
    return SharedReal(*value / *other.value);
  }

  // Arithmetic operators with primitives

  /**
   * @brief Overloads the binary addition operator (`+`) for an integer.
   *
   * @details Adds an integer value to the current object's value. This
   * operation does not modify the current object; it returns a new
   * `SharedReal` object containing the sum.
   *
   * @param other The integer value to add to the current object.
   * @return A new `SharedReal` object containing the sum.
   */
  SharedReal operator+(const int& other) const {
    return SharedReal(*value + other);
  }

  /**
   * @brief Overloads the binary subtraction operator (`-`) for an integer.
   *
   * @details Subtracts an integer value from the current object's value.
   * This operation does not modify the current object; it returns a new
   * `SharedReal` object containing the result.
   *
   * @param other The integer value to subtract from the current object.
   * @return A new `SharedReal` object containing the result.
   */
  SharedReal operator-(const int& other) const {
    return SharedReal(*value - other);
  }

  /**
   * @brief Overloads the binary multiplication operator (`*`) for an
   * integer.
   *
   * @details Multiplies the current object's value by an integer. This
   * operation does not modify the current object; it returns a new
   * `SharedReal` object containing the product.
   *
   * @param other The integer value to multiply the current object by.
   * @return A new `SharedReal` object containing the product.
   */
  SharedReal operator*(const int& other) const {
    return SharedReal(*value * other);
  }

  /**
   * @brief Overloads the binary division operator (`/`) for an integer.
   *
   * @details Divides the current object's value by an integer. This
   * operation does not modify the current object; it returns a new
   * `SharedReal` object containing the quotient.
   *
   * @param other The integer value to divide the current object by.
   * @return A new `SharedReal` object containing the quotient.
   */
  SharedReal operator/(const int& other) const {
    return SharedReal(*value / other);
  }

  // Compound assignment operators with SharedPrimitive

  /**
   * @brief Overloads the compound assignment operator (`+=`).
   *
   * @details Adds the integer value of `other` to the current object's
   * value, modifying the object in place.
   *
   * @param other The SharedReal object to add.
   * @return A reference to the current object (`*this`) after the
   * addition.
   */
  SharedReal& operator+=(const SharedReal& other) {
    *value += *other.value;
    return *this;
  }

  /**
   * @brief Overloads the compound assignment operator (`-=`).
   *
   * @details Subtracts the integer value of `other` from the current
   * object's value, modifying the object in place.
   *
   * @param other The SharedReal object to subtract.
   * @return A reference to the current object (`*this`) after the
   * subtraction.
   */
  SharedReal& operator-=(const SharedReal& other) {
    *value -= *other.value;
    return *this;
  }

  /**
   * @brief Overloads the compound assignment operator (`*=`).
   *
   * @details Multiplies the integer value of the current object by the
   * value of `other`, modifying the object in place.
   *
   * @param other The SharedReal object to multiply by.
   * @return A reference to the current object (`*this`) after the
   * multiplication.
   */
  SharedReal& operator*=(const SharedReal& other) {
    *value *= *other.value;
    return *this;
  }

  /**
   * @brief Overloads the compound assignment operator (`/=`).
   *
   * @details Divides the integer value of the current object by the
   * value of `other`, modifying the object in place.
   *
   * @param other The SharedReal object to divide by.
   * @return A reference to the current object (`*this`) after the
   * division.
   */
  SharedReal& operator/=(const SharedReal& other) {
    *value /= *other.value;
    return *this;
  }

  /**
   * @brief Overloads the compound assignment operator (`+=`) for an
   * integer.
   *
   * @details Adds an integer value to the current object's value,
   * modifying the object in place.
   *
   * @param other The integer value to add to the current object.
   * @return A reference to the current object (`*this`) after the
   * addition.
   */
  SharedReal& operator+=(const int& other) {
    *value += other;
    return *this;
  }

  /**
   * @brief Overloads the compound assignment operator (`-=`) for an
   * integer.
   *
   * @details Subtracts an integer value from the current object's value,
   * modifying the object in place.
   *
   * @param other The integer value to subtract from the current object.
   * @return A reference to the current object (`*this`) after the
   * subtraction.
   */
  SharedReal& operator-=(const int& other) {
    *value -= other;
    return *this;
  }

  /**
   * @brief Overloads the compound assignment operator (`*=`) for an
   * integer.
   *
   * @details Multiplies the integer value of the current object by the
   * integer value of `other`, modifying the object in place.
   *
   * @param other The integer value to multiply the current object by.
   * @return A reference to the current object (`*this`) after the
   * multiplication.
   */
  SharedReal& operator*=(const int& other) {
    *value *= other;
    return *this;
  }

  /**
   * @brief Overloads the compound assignment operator (`/=`) for an
   * integer.
   *
   * @details Divides the integer value of the current object by the
   * integer value of `other`, modifying the object in place.
   *
   * @param other The integer value to divide the current object by.
   * @return A reference to the current object (`*this`) after the
   * division.
   */
  SharedReal& operator/=(const int& other) {
    *value /= other;
    return *this;
  }

  // Relational operators

  /**
   * @brief Overloads the equality operator (`==`).
   *
   * @details Compares the integer value of the current object with the
   * integer value of `other` for equality. This is a non-mutating
   * operation.
   *
   * @param other The SharedReal object to compare against.
   * @return `true` if the values are equal, `false` otherwise.
   */
  bool operator==(const SharedReal& other) const {
    return *value == *other.value;
  }

  /**
   * @brief Overloads the inequality operator (`!=`).
   *
   * @details Compares the integer value of the current object with the
   * integer value of `other` for inequality. This is a non-mutating
   * operation.
   *
   * @param other The SharedReal object to compare against.
   * @return `true` if the values are not equal, `false` otherwise.
   */
  bool operator!=(const SharedReal& other) const {
    return *value != *other.value;
  }

  /**
   * @brief Overloads the less-than operator (`<`).
   *
   * @details Compares the integer value of the current object with the
   * integer value of `other`. This is a non-mutating operation.
   *
   * @param other The SharedReal object to compare against.
   * @return `true` if the current object's value is less than `other`'s
   * value, `false` otherwise.
   */
  bool operator<(const SharedReal& other) const {
    return *value < *other.value;
  }

  /**
   * @brief Overloads the less-than-or-equal-to operator (`<=`).
   *
   * @details Compares the integer value of the current object with the
   * integer value of `other`. This is a non-mutating operation.
   *
   * @param other The SharedReal object to compare against.
   * @return `true` if the current object's value is less than or equal
   * to `other`'s value, `false` otherwise.
   */
  bool operator<=(const SharedReal& other) const {
    return *value <= *other.value;
  }

  /**
   * @brief Overloads the greater-than operator (`>`).
   *
   * @details Compares the integer value of the current object with the
   * integer value of `other`. This is a non-mutating operation.
   *
   * @param other The SharedReal object to compare against.
   * @return `true` if the current object's value is greater than `other`'s
   * value, `false` otherwise.
   */
  bool operator>(const SharedReal& other) const {
    return *value > *other.value;
  }

  /**
   * @brief Overloads the greater-than-or-equal-to operator (`>=`).
   *
   * @details Compares the integer value of the current object with the
   * integer value of `other`. This is a non-mutating operation.
   *
   * @param other The SharedReal object to compare against.
   * @return `true` if the current object's value is greater than or
   * equal to `other`'s value, `false` otherwise.
   */
  bool operator>=(const SharedReal& other) const {
    return *value >= *other.value;
  }

  // Relational operators with primitives

  /**
   * @brief Overloads the equality operator (`==`) for an integer value.
   *
   * @details Compares the integer value of the current object with an
   * `int` for equality. This is a non-mutating operation.
   *
   * @param other The integer value to compare against.
   * @return `true` if the values are equal, `false` otherwise.
   */
  bool operator==(const int& other) const { return *value == other; }

  /**
   * @brief Overloads the inequality operator (`!=`) for an integer.
   *
   * @details Compares the integer value of the current object with an
   * `int` for inequality. This is a non-mutating operation.
   *
   * @param other The integer value to compare against.
   * @return `true` if the values are not equal, `false` otherwise.
   */
  bool operator!=(const int& other) const { return *value != other; }

  /**
   * @brief Overloads the less-than operator (`<`) for an integer.
   *
   * @details Compares the integer value of the current object with an
   * `int`. This is a non-mutating operation.
   *
   * @param other The integer value to compare against.
   * @return `true` if the current object's value is less than `other`,
   * `false` otherwise.
   */
  bool operator<(const int& other) const { return *value < other; }

  /**
   * @brief Overloads the less-than-or-equal-to operator (`<=`) for an
   * integer.
   *
   * @details Compares the integer value of the current object with an
   * `int`. This is a non-mutating operation.
   *
   * @param other The integer value to compare against.
   * @return `true` if the current object's value is less than or equal
   * to `other`, `false` otherwise.
   */
  bool operator<=(const int& other) const { return *value <= other; }

  /**
   * @brief Overloads the greater-than operator (`>`) for an integer.
   *
   * @details Compares the integer value of the current object with an
   * `int`. This is a non-mutating operation.
   *
   * @param other The integer value to compare against.
   * @return `true` if the current object's value is greater than
   * `other`, `false` otherwise.
   */
  bool operator>(const int& other) const { return *value > other; }

  /**
   * @brief Overloads the greater-than-or-equal-to operator (`>=`) for an
   * integer.
   *
   * @details Compares the integer value of the current object with an
   * `int`. This is a non-mutating operation.
   *
   * @param other The integer value to compare against.
   * @return `true` if the current object's value is greater than or
   * equal to `other`, `false` otherwise.
   */
  bool operator>=(const int& other) const { return *value >= other; }

  /**
   * @brief Overloads the stream insertion operator (`<<`) for SharedReal.
   *
   * @details Provides a way to print the integer value of a SharedReal object
   * to an output stream.
   *
   * @param os The output stream to write to.
   * @param sp The SharedReal object to print.
   * @return A reference to the output stream, allowing for chained insertions.
   */
  friend std::ostream& operator<<(std::ostream& os, const SharedReal& sp) {
    os << *sp.value;
    return os;
  }
};

/**
 * @brief Overloads the binary addition operator (`+`) for a double
 * left-hand side operand.
 *
 * @details Adds a double to a SharedReal's value, returning a new
 * SharedReal object with the result. This enables expressions
 * like `5.0 + my_shared_real`.
 *
 * @param lhs The double value on the left-hand side of the operator.
 * @param rhs The SharedReal object on the right-hand side.
 * @return A new SharedReal object containing the sum.
 */
SharedReal operator+(const double& lhs, const SharedReal& rhs) {
  return SharedReal(lhs + rhs.get());
}

/**
 * @brief Overloads the binary subtraction operator (`-`) for a double
 * left-hand side operand.
 *
 * @details Subtracts a SharedReal's value from a double, returning a
 * new SharedReal object with the result. This enables expressions
 * like `10.0 - my_shared_real`.
 *
 * @param lhs The double value on the left-hand side of the operator.
 * @param rhs The SharedReal object on the right-hand side.
 * @return A new SharedReal object containing the result of the
 * subtraction.
 */
SharedReal operator-(const double& lhs, const SharedReal& rhs) {
  return SharedReal(lhs - rhs.get());
}

/**
 * @brief Overloads the binary multiplication operator (`*`) for a
 * double left-hand side operand.
 *
 * @details Multiplies a double by a SharedReal's value, returning a
 * new SharedReal object with the product.
 *
 * @param lhs The double value on the left-hand side of the operator.
 * @param rhs The SharedReal object on the right-hand side.
 * @return A new SharedReal object containing the product.
 */
SharedReal operator*(const double& lhs, const SharedReal& rhs) {
  return SharedReal(lhs * rhs.get());
}

/**
 * @brief Overloads the binary division operator (`/`) for a double
 * left-hand side operand.
 *
 * @details Divides a double by a SharedReal's value, returning a new
 * SharedReal object with the quotient.
 *
 * @param lhs The double value on the left-hand side of the operator.
 * @param rhs The SharedReal object on the right-hand side.
 * @return A new SharedReal object containing the quotient.
 */
SharedReal operator/(const double& lhs, const SharedReal& rhs) {
  return SharedReal(lhs / rhs.get());
}

/**
 * @class SharedString
 * @brief A class that provides shared ownership of a string.
 *
 * @details This class wraps a `std::shared_ptr` to provide a reference-counted
 * string value. When a SharedString object is copied, it shares the same
 * underlying string with the original object. The string's memory is
 * automatically deallocated when the last SharedString object pointing to it
 * is destroyed.
 */
class SharedString {
 private:
  std::shared_ptr<std::string> value;

 public:
  /**
   * @brief Constructs a new SharedString object with a default, empty value.
   *
   * @details Initializes the object's internal shared pointer to manage a new
   * string that is initially empty.
   */
  SharedString() : value(std::make_shared<std::string>()) {}

  /**
   * @brief Constructs a new SharedString object from a string value.
   *
   * @details Initializes the object's internal shared pointer to manage a new
   * string with the value provided by the `val` parameter.
   *
   * @param val The string value to be stored in the shared pointer.
   */
  SharedString(std::string val) : value(std::make_shared<std::string>(val)) {}

  /**
   * @brief Copy constructs a new SharedString object.
   *
   * @details Initializes the object by creating a new shared pointer that
   * shares ownership of the string managed by another SharedString object.
   *
   * @param other The existing SharedString object to copy from.
   */
  SharedString(const SharedString& other) : value(other.value) {}

  /**
   * @brief Overloaded copy assignment operator.
   *
   * @details Assigns the shared state of `other` to the current object. If the
   * objects are not the same, the current object will release its old resource
   * and share ownership of the string value managed by `other`.
   *
   * @param other The SharedString object to assign from.
   * @return A reference to the current object (`*this`) to allow for chained
   * assignments.
   */
  SharedString& operator=(const SharedString& other) {
    if (this != &other) {
      value = other.value;
    }
    return *this;
  }

  /**
   * @brief Overloaded assignment operator for a string value.
   *
   * @details Assigns a new string value to the underlying shared string,
   * modifying the object in place.
   *
   * @param other The string value to assign.
   * @return A reference to the current object (`*this`) to allow for
   * chained assignments.
   */
  SharedString& operator=(const std::string& other) {
    *value = other;
    return *this;
  }

  /**
   * @brief Constructs a new SharedString object by moving resources.
   *
   * @details Transfers ownership of the shared string from `other` to
   * the new object. This is a non-throwing operation that is more
   * efficient than a copy.
   *
   * @param other The temporary SharedString object to move from. After
   * this call, `other` will no longer own the resource.
   */
  SharedString(SharedString&& other) noexcept : value(std::move(other.value)) {}

  /**
   * @brief Overloaded move assignment operator.
   *
   * @details Moves the shared state from `other` to the current object,
   * releasing any resources the current object might have held. This is a
   * non-throwing and more efficient operation than a copy assignment.
   *
   * @param other The temporary SharedString object to move from.
   * @return A reference to the current object (`*this`).
   */
  SharedString& operator=(SharedString&& other) noexcept {
    if (this != &other) {
      value = std::move(other.value);
    }
    return *this;
  }

  /**
   * @brief Retrieves the string value managed by the object.
   *
   * @details This is a getter function that returns a copy of the string
   * value. The function is `const` and can be called on a constant
   * instance of the class without modifying its state.
   *
   * @return The string value managed by the shared pointer.
   */
  std::string get() const { return *value; }

  /**
   * @brief Sets the string value of the object.
   *
   * @details Assigns a new string value to the underlying shared string.
   *
   * @param val The string value to set.
   */
  void set(std::string val) { *value = val; }

  /**
   * @brief User-defined conversion to `std::string`.
   *
   * @details This conversion operator allows the object to be implicitly
   * converted to a `std::string`. The returned value is the string
   * managed by the object's internal shared pointer.
   *
   * @return The string value held by the object.
   */
  operator std::string() { return this->get(); }

  /**
   * @brief Overloads the dereference operator (`*`).
   *
   * @details Provides direct access to the string value managed by the
   * internal shared pointer. This function is `const` and provides a
   * read-only view of the data.
   *
   * @return The string value held by the object.
   */
  std::string operator*() const { return *value; }

  /**
   * @brief Overloads the member access operator (`->`).
   *
   * @details This function provides a way to access the underlying
   * string value by returning a raw pointer to it. It returns the
   * result of the `std::shared_ptr::get()` method.
   *
   * @return A raw pointer (`std::string*`) to the string managed by
   * the shared pointer.
   */
  std::string* operator->() { return value.get(); }

  /**
   * @brief Overloads the member access operator (`->`) for const objects.
   *
   * @details This function provides a way to get a read-only raw pointer
   * to the underlying string. The `const` return type prevents
   * modification of the string value through this pointer. The function
   * itself is also `const`, ensuring it can be called on `const`
   * instances of the class.
   *
   * @return A `const` raw pointer to the string managed by the shared
   * pointer.
   */
  const std::string* operator->() const { return value.get(); }

  /**
   * @brief Overloads the stream insertion operator (`<<`) for
   * SharedString.
   *
   * @details Provides a way to print the string value of a SharedString
   * object to an output stream.
   *
   * @param os The output stream to write to.
   * @param sp The SharedString object to print.
   * @return A reference to the output stream, allowing for chained
   * insertions.
   */
  friend std::ostream& operator<<(std::ostream& os, const SharedString& sp) {
    os << *sp.value;
    return os;
  }
};

/**
 * @class SharedBoolean
 * @brief A class that provides shared ownership of a boolean value.
 *
 * @details This class wraps a `std::shared_ptr` to provide a reference-counted
 * boolean value. When a SharedBoolean object is copied, it shares the same
 * underlying boolean with the original object. The boolean's memory is
 * automatically deallocated when the last SharedBoolean object pointing to it
 * is destroyed.
 */
class SharedBoolean {
 private:
  std::shared_ptr<bool> value;

 public:
  /**
   * @brief Constructs a new SharedBoolean object with a default value.
   *
   * @details Initializes the object's internal shared pointer to manage a new
   * boolean with a default value of `false`.
   */
  SharedBoolean() : value(std::make_shared<bool>(0)) {}

  /**
   * @brief Constructs a new SharedBoolean object from a boolean value.
   *
   * @details Initializes the object's internal shared pointer to manage a new
   * boolean with the value provided by the `val` parameter.
   *
   * @param val The boolean value to be stored in the shared pointer.
   */
  SharedBoolean(bool val) : value(std::make_shared<bool>(val)) {}

  /**
   * @brief Copy constructs a new SharedBoolean object.
   *
   * @details Initializes the object by creating a new shared pointer that
   * shares ownership of the boolean managed by another SharedBoolean object.
   *
   * @param other The existing SharedBoolean object to copy from.
   */
  SharedBoolean(const SharedBoolean& other) : value(other.value) {}

  /**
   * @brief Overloaded copy assignment operator.
   *
   * @details Assigns the shared state of `other` to the current object. If the
   * objects are not the same, the current object will release its old resource
   * and share ownership of the boolean value managed by `other`.
   *
   * @param other The SharedBoolean object to assign from.
   * @return A reference to the current object (`*this`) to allow for chained
   * assignments.
   */
  SharedBoolean& operator=(const SharedBoolean& other) {
    if (this != &other) {
      value = other.value;
    }
    return *this;
  }

  /**
   * @brief Overloaded assignment operator for a boolean value.
   *
   * @details Assigns a new boolean value to the underlying shared boolean,
   * modifying the object in place.
   *
   * @param other The boolean value to assign.
   * @return A reference to the current object (`*this`) to allow for
   * chained assignments.
   */
  SharedBoolean& operator=(const bool& other) {
    *value = other;
    return *this;
  }

  /**
   * @brief Constructs a new SharedBoolean object by moving resources.
   *
   * @details Transfers ownership of the shared boolean from `other` to the new
   * object. This is a non-throwing operation that is more efficient than a
   * copy.
   *
   * @param other The temporary SharedBoolean object to move from. After this
   * call, `other` will no longer own the resource.
   */
  SharedBoolean(SharedBoolean&& other) noexcept
      : value(std::move(other.value)) {}

  /**
   * @brief Overloaded move assignment operator.
   *
   * @details Moves the shared state from `other` to the current object,
   * releasing any resources the current object might have held. This is a
   * non-throwing and more efficient operation than a copy assignment.
   *
   * @param other The temporary SharedBoolean object to move from.
   * @return A reference to the current object (`*this`).
   */
  SharedBoolean& operator=(SharedBoolean&& other) noexcept {
    if (this != &other) {
      value = std::move(other.value);
    }
    return *this;
  }

  /**
   * @brief Retrieves the boolean value managed by the object.
   *
   * @details This is a getter function that returns a copy of the boolean
   * value. Since the function is `const`, it can be safely called on a
   * constant instance of the class without modifying its state.
   *
   * @return The boolean value managed by the shared pointer.
   */
  bool get() const { return *value; }

  /**
   * @brief Sets the boolean value of the object.
   *
   * @details Assigns a new boolean value to the underlying shared boolean.
   *
   * @param val The boolean value to set.
   */
  void set(bool val) { *value = val; }

  /**
   * @brief User-defined conversion to `bool`.
   *
   * @details This conversion operator allows the object to be implicitly
   * converted to a `bool`. The returned value is the boolean managed by the
   * object's internal shared pointer.
   *
   * @return The boolean value held by the object.
   */
  operator bool() { return this->get(); }

  /**
   * @brief Overloads the dereference operator (`*`).
   *
   * @details Provides direct access to the boolean value managed by the
   * internal shared pointer. This function is `const` and provides a
   * read-only view of the data.
   *
   * @return The boolean value held by the object.
   */
  bool operator*() const { return *value; }

  /**
   * @brief Overloads the member access operator (`->`).
   *
   * @details This function provides a way to access the underlying boolean
   * value by returning a raw pointer to it. It returns the result of the
   * `std::shared_ptr::get()` method.
   *
   * @return A raw pointer (`bool*`) to the boolean managed by the
   * shared pointer.
   */
  bool* operator->() { return value.get(); }

  /**
   * @brief Overloads the member access operator (`->`) for const objects.
   *
   * @details This function provides a way to get a read-only raw pointer
   * to the underlying boolean. The `const` return type prevents
   * modification of the boolean value through this pointer. The function
   * itself is also `const`, ensuring it can be called on `const`
   * instances of the class.
   *
   * @return A `const` raw pointer to the boolean managed by the shared
   * pointer.
   */
  const bool* operator->() const { return value.get(); }

  /**
   * @brief Overloads the equality operator (`==`).
   *
   * @details Compares the boolean value of the current object with the
   * boolean value of `other` for equality. This is a non-mutating
   * operation.
   *
   * @param other The SharedBoolean object to compare against.
   * @return `true` if the values are equal, `false` otherwise.
   */
  bool operator==(const SharedBoolean& other) const {
    return *value == *other.value;
  }

  /**
   * @brief Overloads the inequality operator (`!=`).
   *
   * @details Compares the boolean value of the current object with the
   * boolean value of `other` for inequality. This is a non-mutating
   * operation.
   *
   * @param other The SharedBoolean object to compare against.
   * @return `true` if the values are not equal, `false` otherwise.
   */
  bool operator!=(const SharedBoolean& other) const {
    return *value != *other.value;
  }

  /**
   * @brief Overloads the less-than operator (`<`).
   *
   * @details Compares the boolean value of the current object with the
   * boolean value of `other`. This is a non-mutating operation.
   *
   * @param other The SharedBoolean object to compare against.
   * @return `true` if the current object's value is less than `other`'s
   * value, `false` otherwise.
   */
  bool operator<(const SharedBoolean& other) const {
    return *value < *other.value;
  }

  /**
   * @brief Overloads the less-than-or-equal-to operator (`<=`).
   *
   * @details Compares the boolean value of the current object with the
   * boolean value of `other`. This is a non-mutating operation.
   *
   * @param other The SharedBoolean object to compare against.
   * @return `true` if the current object's value is less than or equal
   * to `other`'s value, `false` otherwise.
   */
  bool operator<=(const SharedBoolean& other) const {
    return *value <= *other.value;
  }

  /**
   * @brief Overloads the greater-than operator (`>`).
   *
   * @details Compares the boolean value of the current object with the
   * boolean value of `other`. This is a non-mutating operation.
   *
   * @param other The SharedBoolean object to compare against.
   * @return `true` if the current object's value is greater than `other`'s
   * value, `false` otherwise.
   */
  bool operator>(const SharedBoolean& other) const {
    return *value > *other.value;
  }

  /**
   * @brief Overloads the greater-than-or-equal-to operator (`>=`).
   *
   * @details Compares the boolean value of the current object with the
   * boolean value of `other`. This is a non-mutating operation.
   *
   * @param other The SharedBoolean object to compare against.
   * @return `true` if the current object's value is greater than or
   * equal to `other`'s value, `false` otherwise.
   */
  bool operator>=(const SharedBoolean& other) const {
    return *value >= *other.value;
  }

  /**
   * @brief Overloads the equality operator (`==`) for a boolean value.
   *
   * @details Compares the boolean value of the current object with a `bool`
   * for equality. This is a non-mutating operation.
   *
   * @param other The boolean value to compare against.
   * @return `true` if the values are equal, `false` otherwise.
   */
  bool operator==(const bool& other) const { return *value == other; }

  /**
   * @brief Overloads the inequality operator (`!=`) for a boolean value.
   *
   * @details Compares the boolean value of the current object with a `bool`
   * for inequality. This is a non-mutating operation.
   *
   * @param other The boolean value to compare against.
   * @return `true` if the values are not equal, `false` otherwise.
   */
  bool operator!=(const bool& other) const { return *value != other; }

  /**
   * @brief Overloads the less-than operator (`<`) for a boolean value.
   *
   * @details Compares the boolean value of the current object with a `bool`.
   * This is a non-mutating operation.
   *
   * @param other The boolean value to compare against.
   * @return `true` if the current object's value is less than `other`,
   * `false` otherwise.
   */
  bool operator<(const bool& other) const { return *value < other; }

  /**
   * @brief Overloads the less-than-or-equal-to operator (`<=`) for a boolean.
   *
   * @details Compares the boolean value of the current object with a `bool`.
   * This is a non-mutating operation.
   *
   * @param other The boolean value to compare against.
   * @return `true` if the current object's value is less than or equal
   * to `other`, `false` otherwise.
   */
  bool operator<=(const bool& other) const { return *value <= other; }

  /**
   * @brief Overloads the greater-than operator (`>`) for a boolean value.
   *
   * @details Compares the boolean value of the current object with a `bool`.
   * This is a non-mutating operation.
   *
   * @param other The boolean value to compare against.
   * @return `true` if the current object's value is greater than `other`,
   * `false` otherwise.
   */
  bool operator>(const bool& other) const { return *value > other; }

  /**
   * @brief Overloads the greater-than-or-equal-to operator (`>=`) for a
   * boolean.
   *
   * @details Compares the boolean value of the current object with a `bool`.
   * This is a non-mutating operation.
   *
   * @param other The boolean value to compare against.
   * @return `true` if the current object's value is greater than or
   * equal to `other`, `false` otherwise.
   */
  bool operator>=(const bool& other) const { return *value >= other; }

  /**
   * @brief Overloads the stream insertion operator (`<<`) for
   * SharedBoolean.
   *
   * @details Provides a way to print the boolean value of a SharedBoolean
   * object to an output stream.
   *
   * @param os The output stream to write to.
   * @param sp The SharedBoolean object to print.
   * @return A reference to the output stream, allowing for chained insertions.
   */
  friend std::ostream& operator<<(std::ostream& os, const SharedBoolean& sp) {
    os << *sp.value;
    return os;
  }
};

/**
 * @brief Overloads the less-than operator (`<`) for a boolean
 * left-hand side operand.
 *
 * @details Compares a boolean to a SharedBoolean's value.
 *
 * @param lhs The boolean value on the left-hand side of the operator.
 * @param rhs The SharedBoolean object on the right-hand side.
 * @return `true` if the boolean is less than the SharedBoolean's
 * value, `false` otherwise.
 */
bool operator<(const bool& lhs, const SharedBoolean& rhs) {
  return (lhs < rhs.get());
}

/**
 * @brief Overloads the less-than-or-equal-to operator (`<=`) for a
 * boolean left-hand side operand.
 *
 * @details Compares a boolean to a SharedBoolean's value.
 *
 * @param lhs The boolean value on the left-hand side of the operator.
 * @param rhs The SharedBoolean object on the right-hand side.
 * @return `true` if the boolean is less than or equal to the
 * SharedBoolean's value, `false` otherwise.
 */
bool operator<=(const bool& lhs, const SharedBoolean& rhs) {
  return (lhs <= rhs.get());
}

/**
 * @brief Overloads the greater-than operator (`>`) for a boolean
 * left-hand side operand.
 *
 * @details Compares a boolean to a SharedBoolean's value.
 *
 * @param lhs The boolean value on the left-hand side of the operator.
 * @param rhs The SharedBoolean object on the right-hand side.
 * @return `true` if the boolean is greater than the SharedBoolean's
 * value, `false` otherwise.
 */
bool operator>(const bool& lhs, const SharedBoolean& rhs) {
  return (lhs > rhs.get());
}

/**
 * @brief Overloads the greater-than-or-equal-to operator (`>=`) for a
 * boolean left-hand side operand.
 *
 * @details Compares a boolean to a SharedBoolean's value.
 *
 * @param lhs The boolean value on the left-hand side of the operator.
 * @param rhs The SharedBoolean object on the right-hand side.
 * @return `true` if the boolean is greater than or equal to the
 * SharedBoolean's value, `false` otherwise.
 */
bool operator>=(const bool& lhs, const SharedBoolean& rhs) {
  return (lhs >= rhs.get());
}

/**
 * @typedef fims_int
 * @brief An alias for the SharedInt class.
 *
 * @details This alias is used to conform to the fims naming convention,
 * representing a reference-counted integer.
 */
typedef SharedInt fims_int;
/**
 * @typedef fims_double
 * @brief An alias for the SharedReal class.
 *
 * @details This alias is used to conform to the fims naming convention,
 * representing a reference-counted real number (integer).
 */
typedef SharedReal fims_double;
/**
 * @typedef fims_string
 * @brief An alias for the SharedString class.
 *
 * @details This alias is used to conform to the fims naming convention,
 * representing a reference-counted string.
 */
typedef SharedString fims_string;
/**
 * @typedef fims_bool
 * @brief An alias for the SharedBoolean class.
 *
 * @details This alias is used to conform to the fims naming convention,
 * representing a reference-counted boolean.
 */
typedef SharedBoolean fims_bool;

#endif

/**
 * @file catch_at_age.hpp
 * @brief Code to specify the catch-at-age model.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_MODELS_CATCH_AT_AGE_HPP
#define FIMS_MODELS_CATCH_AT_AGE_HPP

#include <set>
#include <regex>

#include "fishery_model_base.hpp"

/* Dictionary block for shared parameter snippet documentations.
 * Referenced in function docs via @snippet{doc} this snippet_id.
  [param_population]
  @param population Shared pointer to the population object.
  [param_population]
  [param_i_age_year]
  @param i_age_year Dimension folded index for age and year.
  [param_i_age_year]
  [param_year]
  @param year Year index.
  [param_year]
  [param_age]
  @param age Age index.
  [param_age]
  [param_i_agem1_yearm1]
  @param i_agem1_yearm1 Dimension folded index for age-1 and year-1.
  [param_i_agem1_yearm1]
  [param_i_dev]
  @param i_dev Index to log_recruit_dev of vector length n_years-1.
  [param_i_dev]
  [param_other]
  @param other The other CatchAtAge object to copy from.
  [param_other]
 */

namespace fims_popdy {

template <typename Type>
/**
 * @brief CatchAtAge is a class containing a catch-at-age model, which is
 * just one of many potential fishery models that can be used in FIMS. The
 * CatchAtAge class inherits from the FisheryModelBase class and can be used
 * to fit both age and length data even though it is called CatchAtAge.
 *
 * See the @ref glossary for definitions of mathematical symbols used below.
 *
 */
class CatchAtAge : public FisheryModelBase<Type> {
 public:
  /**
   * @brief The name of the model.
   *
   */
  std::string name_m;

  /**
   * @brief Iterate the derived quantities.
   *
   */
  typedef typename std::map<std::string, fims::Vector<Type>>::iterator
      derived_quantities_iterator;

  /**
   * @brief Used to iterate through fleet-based derived quantities.
   *
   */
  typedef typename std::map<uint32_t,
                            std::map<std::string, fims::Vector<Type>>>::iterator
      fleet_derived_quantities_iterator;

  /**
   * @brief Used to iterate through fleet-based derived quantities dimensions.
   */
  typedef
      typename std::map<uint32_t,
                        std::map<std::string, fims::Vector<size_t>>>::iterator
          fleet_derived_quantities_dims_iterator;
  /**
   * @brief Used to iterate through population-based derived quantities.
   *
   */
  typedef typename std::map<uint32_t,
                            std::map<std::string, fims::Vector<Type>>>::iterator
      population_derived_quantities_iterator;

  /**
   * @brief Used to iterate through population-based derived quantities
   * dimensions.
   */
  typedef
      typename std::map<uint32_t,
                        std::map<std::string, fims::Vector<size_t>>>::iterator
          population_derived_quantities_dims_iterator;

  /**
   * @brief Iterate through fleets.
   *
   */
  typedef typename std::map<uint32_t,
                            std::shared_ptr<fims_popdy::Fleet<Type>>>::iterator
      fleet_iterator;
  /**
   * @brief Iterate through derived quantities.
   *
   */
  typedef
      typename std::map<std::string, fims::Vector<Type>>::iterator dq_iterator;
  /**
   * @brief A map of report vectors for the object.
   * used to populate the report_vectors map in for submodule
   * parameters.
   */
  std::map<std::string, fims::Vector<fims::Vector<Type>>> report_vectors;

 public:
  std::vector<Type> ages; /*!< vector of the ages for referencing*/
  /**
   * Constructor for the CatchAtAge class. This constructor initializes the
   * name of the model and sets the id of the model.
   */
  CatchAtAge() : FisheryModelBase<Type>() {
    std::stringstream ss;
    ss << "caa_" << this->GetId() << "_";
    this->name_m = ss.str();
    this->model_type_m = "caa";
  }

  /**
   * @brief Copy constructor for the CatchAtAge class.
   *
   * @snippet{doc} this param_other
   */
  CatchAtAge(const CatchAtAge &other)
      : FisheryModelBase<Type>(other), name_m(other.name_m), ages(other.ages) {
    this->model_type_m = "caa";
  }

  /**
   * @brief Destroy the Catch At Age object.
   *
   */
  virtual ~CatchAtAge() {}

  /**
   * This function is called once at the beginning of the model run. It
   * initializes the derived quantities for the populations and fleets.
   */
  virtual void Initialize() {
    for (size_t p = 0; p < this->populations.size(); p++) {
      this->populations[p]->proportion_female.resize(
          this->populations[p]->n_ages);

      this->populations[p]->M.resize(this->populations[p]->n_years *
                                     this->populations[p]->n_ages);

      this->populations[p]->f_multiplier.resize(this->populations[p]->n_years);

      this->populations[p]->spawning_biomass_ratio.resize(
          (this->populations[p]->n_years + 1));
    }

    for (fleet_iterator fit = this->fleets.begin(); fit != this->fleets.end();
         ++fit) {
      std::shared_ptr<fims_popdy::Fleet<Type>> &fleet = (*fit).second;

      if (fleet->log_q.size() == 0) {
        fleet->log_q.resize(1);
        fleet->log_q[0] = static_cast<Type>(0.0);
      }
      fleet->q.resize(fleet->log_q.size());
      fleet->Fmort.resize(fleet->n_years);
    }
  }

  /**
   * This function is used to reset the derived quantities of a population or
   * fleet to a given value.
   */
  virtual void Prepare() {
    for (size_t p = 0; p < this->populations.size(); p++) {
      std::shared_ptr<fims_popdy::Population<Type>> &population =
          this->populations[p];

      auto &derived_quantities =
          this->GetPopulationDerivedQuantities(population->GetId());

      // Reset the derived quantities for the population
      for (auto &kv : derived_quantities) {
        this->ResetVector(kv.second);
      }

      // Prepare proportion_female
      for (size_t age = 0; age < population->n_ages; age++) {
        population->proportion_female[age] = 0.5;
      }

      // Transformation Section
      for (size_t age = 0; age < population->n_ages; age++) {
        for (size_t year = 0; year < population->n_years; year++) {
          size_t i_age_year = age * population->n_years + year;
          population->M[i_age_year] =
              fims_math::exp(population->log_M[i_age_year]);
        }
      }

      for (size_t year = 0; year < population->n_years; year++) {
        population->f_multiplier[year] =
            fims_math::exp(population->log_f_multiplier[year]);
      }
    }

    for (fleet_iterator fit = this->fleets.begin(); fit != this->fleets.end();
         ++fit) {
      std::shared_ptr<fims_popdy::Fleet<Type>> &fleet = (*fit).second;
      auto &derived_quantities =
          this->GetFleetDerivedQuantities(fleet->GetId());

      for (auto &kv : derived_quantities) {
        this->ResetVector(kv.second);
      }

      // Transformation Section
      for (size_t i = 0; i < fleet->log_q.size(); i++) {
        fleet->q[i] = fims_math::exp(fleet->log_q[i]);
      }

      for (size_t year = 0; year < fleet->n_years; year++) {
        fleet->Fmort[year] = fims_math::exp(fleet->log_Fmort[year]);
      }
    }
  }
  /**
   * This function is used to add a population id to the set of population ids.
   */
  void AddPopulation(uint32_t id) { this->population_ids.insert(id); }

  /**
   * @brief Get the population ids of the model.
   */
  std::set<uint32_t> &GetPopulationIds() { return this->population_ids; }

  /**
   * This function is used to get the populations of the model. It returns a
   * vector of shared pointers to the populations.
   * @return std::vector<std::shared_ptr<fims_popdy::Population<Type>>>&
   */
  std::vector<std::shared_ptr<fims_popdy::Population<Type>>> &GetPopulations() {
    return this->populations;
  }

  /**
   * @brief Calculates initial numbers at age for index and age.
   *
   * The formula used is:
   * \f[
   * N_{a,0} = \exp(\log N_{a,0})
   * \f]
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_i_age_year
   * @snippet{doc} this param_age
   */
  void CalculateInitialNumbersAA(
      std::shared_ptr<fims_popdy::Population<Type>> &population,
      size_t i_age_year, size_t age) {
    std::map<std::string, fims::Vector<Type>> &dq_ =
        this->GetPopulationDerivedQuantities(population->GetId());

    dq_["numbers_at_age"][i_age_year] =
        fims_math::exp(population->log_init_naa[age]);
  }

  /**
   * @brief Calculates numbers at age for a population.
   *
   * This function calculates numbers at age by applying total mortality
   * \f$Z\f$ to individuals from the previous time step. It also handles
   * the accumulation of a plus group.
   *
   * Standard update:
   * \f[
   * N_{a,y} = N_{a-1,y-1} \exp(-Z_{a-1,y-1})
   * \f]
   *
   * Plus group update (if \f$a = A\f$):
   * \f[
   * N_{A,y} = N_{A-1,y-1} \exp(-Z_{A-1,y-1}) + N_{A,y-1} \exp(-Z_{A,y-1})
   * \f]
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_i_age_year
   * @snippet{doc} this param_i_agem1_yearm1
   * @snippet{doc} this param_age
   */
  void CalculateNumbersAA(
      std::shared_ptr<fims_popdy::Population<Type>> &population,
      size_t i_age_year, size_t i_agem1_yearm1, size_t age) {
    // using Z from previous age/year

    std::map<std::string, fims::Vector<Type>> &dq_ =
        this->GetPopulationDerivedQuantities(population->GetId());

    dq_["numbers_at_age"][i_age_year] =
        dq_["numbers_at_age"][i_agem1_yearm1] *
        (fims_math::exp(-dq_["mortality_Z"][i_agem1_yearm1]));

    // Plus group calculation
    if (age == (population->n_ages - 1)) {
      dq_["numbers_at_age"][i_age_year] =
          dq_["numbers_at_age"][i_age_year] +
          dq_["numbers_at_age"][i_agem1_yearm1 + 1] *
              (fims_math::exp(-dq_["mortality_Z"][i_agem1_yearm1 + 1]));
    }
  }

  /**
   * @brief Calculates unfished numbers at age at year and age specific indices.
   *
   * This function computes unfished numbers at age by applying survival
   * through time using only natural mortality, without any fishing pressure.
   * It also accounts for accumulation of the plus group.
   *
   * Standard update:
   * \f[
   * N^U_{a,y} = N^U_{a-1,y-1} \exp(-M_{a-1,y-1})
   * \f]
   *
   * Plus group update (if \f$a = A\f$):
   * \f[
   * N^U_{A,y} = N^U_{A-1,y-1} \exp(-M_{A-1,y-1}) + N^U_{A,y-1} \exp(-M_{A,y-1})
   * \f]
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_i_age_year
   * @snippet{doc} this param_i_agem1_yearm1
   * @snippet{doc} this param_age
   */
  void CalculateUnfishedNumbersAA(
      std::shared_ptr<fims_popdy::Population<Type>> &population,
      size_t i_age_year, size_t i_agem1_yearm1, size_t age) {
    std::map<std::string, fims::Vector<Type>> &dq_ =
        this->GetPopulationDerivedQuantities(population->GetId());

    // using M from previous age/year
    dq_["unfished_numbers_at_age"][i_age_year] =
        dq_["unfished_numbers_at_age"][i_agem1_yearm1] *
        (fims_math::exp(-population->M[i_agem1_yearm1]));

    // Plus group calculation
    if (age == (population->n_ages - 1)) {
      dq_["unfished_numbers_at_age"][i_age_year] =
          dq_["unfished_numbers_at_age"][i_age_year] +
          dq_["unfished_numbers_at_age"][i_agem1_yearm1 + 1] *
              (fims_math::exp(-population->M[i_agem1_yearm1 + 1]));
    }
  }

  /**
   * @brief Calculates total mortality for a population.
   *
   * This function calculates total mortality \f$Z\f$ for a specific age and
   * year, combining natural mortality \f$M\f$ and fishing mortality \f$F\f$
   * from all fleets.
   *
   * The fishing mortality \f$F_{f,a,y}\f$ for each fleet \f$f\f$ is computed
   * using age-specific selectivity \f$S_f(a)\f$, fleet-specific annual
   * fishing mortality \f$F_{f,y}\f$, and year-specific F multiplier
   * \f$f_y\f$:
   * \f[
   * F_{f,a,y} = F_{f,y} \times f_y \times S_f(a)
   * \f]
   *
   * Total fishing mortality at age \f$a\f$ and year \f$y\f$ is the sum over
   * fleets:
   * \f[
   * F_{a,y} = \sum_{f=1}^{N_{fleets}} F_{f,a,y}
   * \f]
   *
   * Total mortality \f$Z_{a,y}\f$ is the sum of natural and fishing mortality:
   * \f[
   * Z_{a,y} = M_{a,y} + F_{a,y}
   * \f]
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_i_age_year
   * @snippet{doc} this param_year
   * @snippet{doc} this param_age
   */
  void CalculateMortality(
      std::shared_ptr<fims_popdy::Population<Type>> &population,
      size_t i_age_year, size_t year, size_t age) {
    std::map<std::string, fims::Vector<Type>> &dq_ =
        this->GetPopulationDerivedQuantities(population->GetId());

    for (size_t fleet_ = 0; fleet_ < population->n_fleets; fleet_++) {
      // evaluate is a member function of the selectivity class
      Type s = population->fleets[fleet_]->selectivity->evaluate(
          population->ages[age], year);

      dq_["mortality_F"][i_age_year] +=
          population->fleets[fleet_]->Fmort[year] *
          population->f_multiplier[year] * s;

      dq_["sum_selectivity"][i_age_year] += s;
    }
    dq_["mortality_M"][i_age_year] = population->M[i_age_year];

    dq_["mortality_Z"][i_age_year] =
        population->M[i_age_year] + dq_["mortality_F"][i_age_year];
  }

  /**
   * @brief Calculates biomass for a population.
   *
   * Adds the biomass at age to the total biomass for a given year \f$y\f$ by
   * multiplying numbers at age \f$a\f$ by weight at age \f$w_a\f$:
   * \f[
   * B_y \mathrel{+}= N_{a,y} \times w_a
   * \f]
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_i_age_year
   * @snippet{doc} this param_year
   * @snippet{doc} this param_age
   */
  void CalculateBiomass(
      std::shared_ptr<fims_popdy::Population<Type>> &population,
      size_t i_age_year, size_t year, size_t age) {
    std::map<std::string, fims::Vector<Type>> &dq_ =
        this->GetPopulationDerivedQuantities(population->GetId());

    dq_["biomass"][year] += dq_["numbers_at_age"][i_age_year] *
                            population->growth->evaluate(year, population->ages[age]);
  }

  /**
   * @brief Calculates the unfished biomass for a population.
   *
   * Updates unfished biomass \f$B^U_y\f$ by adding the biomass of age \f$a\f$
   * in year \f$y\f$:
   * \f[
   * B^U_y \mathrel{+}= N^U_{a,y} \times w_a
   * \f]
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_i_age_year
   * @snippet{doc} this param_year
   * @snippet{doc} this param_age
   */
  void CalculateUnfishedBiomass(
      std::shared_ptr<fims_popdy::Population<Type>> &population,
      size_t i_age_year, size_t year, size_t age) {
    std::map<std::string, fims::Vector<Type>> &dq_ =
        this->GetPopulationDerivedQuantities(population->GetId());

    dq_["unfished_biomass"][year] +=
        dq_["unfished_numbers_at_age"][i_age_year] *
        population->growth->evaluate(year,population->ages[age]);
  }

  /**
   * @brief Calculates spawning biomass for a population.
   *
   * This function computes yearly \f$y\f$ spawning biomass \f$SB_y\f$ by
   * summing the contributions from each age \f$a\f$, accounting for proportion
   * female, proportion mature, and weight at age \f$w_a\f$:
   * \f[
   * SB_y \mathrel{+}= N_{a,y} \times w_a \times p_{female,a} \times
   * p_{mature,a}
   * \f]
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_i_age_year
   * @snippet{doc} this param_year
   * @snippet{doc} this param_age
   */
  void CalculateSpawningBiomass(
      std::shared_ptr<fims_popdy::Population<Type>> &population,
      size_t i_age_year, size_t year, size_t age) {
    std::map<std::string, fims::Vector<Type>> &dq_ =
        this->GetPopulationDerivedQuantities(population->GetId());

    dq_["spawning_biomass"][year] +=
        population->proportion_female[age] * dq_["numbers_at_age"][i_age_year] *
        dq_["proportion_mature_at_age"][i_age_year] *
        population->growth->evaluate(year,population->ages[age]);
  }

  /**
   * @brief Calculated unfished spawning biomass for a population
   *
   * Updates unfished spawning biomass \f$SB^U_y\f$ by adding the biomass of age
   * \f$a\f$ in year \f$y\f$:
   * \f[
   * SB^U_y \mathrel{+}= N^U_{a,y} \times w_a \times p_{female,a} \times
   * p_{mature,a}
   * \f]
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_i_age_year
   * @snippet{doc} this param_year
   * @snippet{doc} this param_age
   */
  void CalculateUnfishedSpawningBiomass(
      std::shared_ptr<fims_popdy::Population<Type>> &population,
      size_t i_age_year, size_t year, size_t age) {
    std::map<std::string, fims::Vector<Type>> &dq_ =
        this->GetPopulationDerivedQuantities(population->GetId());

    dq_["unfished_spawning_biomass"][year] +=
        population->proportion_female[age] *
        dq_["unfished_numbers_at_age"][i_age_year] *
        dq_["proportion_mature_at_age"][i_age_year] *
        population->growth->evaluate(year,population->ages[age]);
  }

  /**
   * @brief Calculate the spawning biomass ratio for a population and year.
   *
   * This method computes the ratio of spawning biomass in a given year to the
   * spawning biomass at year zero (typically unfished), for the specified
   * population:
   * \f[
   * \text{ratio}_y = \frac{SB_y}{SB^U_0}
   * \f]
   *
   * The result is stored in the population's spawning_biomass_ratio vector.
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_year
   */
  void CalculateSpawningBiomassRatio(
      std::shared_ptr<fims_popdy::Population<Type>> &population, size_t year) {
    std::map<std::string, fims::Vector<Type>> &dq_ =
        this->GetPopulationDerivedQuantities(population->GetId());
    population->spawning_biomass_ratio[year] =
        dq_["spawning_biomass"][year] / dq_["unfished_spawning_biomass"][0];
  }

  /**
   * @brief Calculates equilibrium spawning biomass per recruit.
   *
   * This function calculates the spawning biomass per recruit \f$\phi_0\f$ at
   * equilibrium, assuming an unfished stock. The biomass is calculated as the
   * sum of the biomass contributions from each age \f$a\f$:
   * \f[
   * \phi_0 = \sum_{a=0}^{A} N_a \times p_{female,a} \times p_{mature,a} \times
   * w_a
   * \f]
   *
   * The numbers at age \f$N_a\f$ are calculated recursively with natural
   * mortality: \f[ N_a = N_{a-1} \times \exp(-M_a) \quad \text{for } a = 1,
   * \ldots, A-1 \f]
   *
   * Plus group update:
   * \f[
   * N_A = \frac{N_{A-1} \times \exp(-M_{A-1})}{1 - \exp(-M_A)}
   * \f]
   *
   * @snippet{doc} this param_population
   * @return Type
   */
  Type CalculateSBPR0(
      std::shared_ptr<fims_popdy::Population<Type>> &population) {
    std::map<std::string, fims::Vector<Type>> &dq_ =
        this->GetPopulationDerivedQuantities(population->GetId());

    std::vector<Type> numbers_spr(population->n_ages, 1.0);
    Type phi_0 = 0.0;
    phi_0 += numbers_spr[0] * population->proportion_female[0] *
             dq_["proportion_mature_at_age"][0] *
             population->growth->evaluate(0,population->ages[0]);
    for (size_t a = 1; a < (population->n_ages - 1); a++) {
      numbers_spr[a] = numbers_spr[a - 1] * fims_math::exp(-population->M[a]);
      phi_0 += numbers_spr[a] * population->proportion_female[a] *
               dq_["proportion_mature_at_age"][a] *
               population->growth->evaluate(0,population->ages[a]);
    }

    numbers_spr[population->n_ages - 1] =
        (numbers_spr[population->n_ages - 2] *
         fims_math::exp(-population->M[population->n_ages - 2])) /
        (1 - fims_math::exp(-population->M[population->n_ages - 1]));
    phi_0 +=
        numbers_spr[population->n_ages - 1] *
        population->proportion_female[population->n_ages - 1] *
        dq_["proportion_mature_at_age"][population->n_ages - 1] *
        population->growth->evaluate(0,population->ages[population->n_ages - 1]);

    return phi_0;
  }

  /**
   * @brief Calculates expected recruitment for a population.
   *
   * Calculates expected recruitment as a function of spawning biomass and
   * equilibrium spawning biomass per recruit \f$\phi_0\f$.
   *
   * The expected recruitment \f$R_y\f$ in year \f$y\f$ is given by:
   * \f[
   * R_y =
   * \begin{cases}
   * f(SB_{y-1}, \phi_0), & \text{if } i_{dev} = n_{years} \\
   * \exp(g(y-1)), & \text{otherwise}
   * \end{cases}
   * \f]
   *
   * Where \f$f()\f$ evaluates mean recruitment based on spawning biomass and
   * \f$\phi_0\f$, and \f$g(y-1)\f$ evaluates recruitment deviations.
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_i_age_year
   * @snippet{doc} this param_year
   * @snippet{doc} this param_i_dev
   */
  void CalculateRecruitment(
      std::shared_ptr<fims_popdy::Population<Type>> &population,
      size_t i_age_year, size_t year, size_t i_dev) {
    std::map<std::string, fims::Vector<Type>> &dq_ =
        this->GetPopulationDerivedQuantities(population->GetId());

    Type phi0 = CalculateSBPR0(population);

    if (i_dev == population->n_years) {
      dq_["numbers_at_age"][i_age_year] =
          population->recruitment->evaluate_mean(
              dq_["spawning_biomass"][year - 1], phi0);
      /*the final year of the time series has no data to inform recruitment
      devs, so this value is set to the mean recruitment.*/
    } else {
      // Why are we using evaluate_mean, how come a virtual function was
      // changed? AMH: there are now two virtual functions: evaluate_mean and
      // evaluate_process (see below)
      population->recruitment->log_expected_recruitment[year - 1] =
          fims_math::log(population->recruitment->evaluate_mean(
              dq_["spawning_biomass"][year - 1], phi0));

      dq_["numbers_at_age"][i_age_year] = fims_math::exp(
          population->recruitment->process->evaluate_process(year - 1));
    }

    dq_["expected_recruitment"][year] = dq_["numbers_at_age"][i_age_year];
  }

  /**
   * @brief Calculates maturity at age, in proportion, for a population.
   *
   * This function evaluates the maturity ogive at the specified age to estimate
   * the proportion of individuals that are mature:
   * \f[
   * p_{mature,a} = \text{maturity}(a)
   * \f]
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_i_age_year
   * @snippet{doc} this param_age
   */
  void CalculateMaturityAA(
      std::shared_ptr<fims_popdy::Population<Type>> &population,
      size_t i_age_year, size_t age) {
    std::map<std::string, fims::Vector<Type>> &dq_ =
        this->GetPopulationDerivedQuantities(population->GetId());

    dq_["proportion_mature_at_age"][i_age_year] =
        population->maturity->evaluate(population->ages[age]);
  }

  /**
   * @brief Calculates total catch (landings) by fleet and population for a
   * given year by aggregating age-specific catch over ages.
   *
   * This function updates fleet-specific and total expected landings for a
   * given year and age by accumulating age-specific catch from each fleet:
   * \f[
   * CW_{f,y} \mathrel{+}= CW_{f,a,y}, \quad
   * C_{f,y} \mathrel{+}= C_{f,a,y}
   * \f]
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_year
   * @snippet{doc} this param_age
   */
  void CalculateLandings(
      std::shared_ptr<fims_popdy::Population<Type>> &population, size_t year,
      size_t age) {
    std::map<std::string, fims::Vector<Type>> &pdq_ =
        this->GetPopulationDerivedQuantities(population->GetId());

    for (size_t fleet_ = 0; fleet_ < population->n_fleets; fleet_++) {
      std::map<std::string, fims::Vector<Type>> &fdq_ =
          this->GetFleetDerivedQuantities(population->fleets[fleet_]->GetId());
      size_t i_age_year = year * population->n_ages + age;

      pdq_["total_landings_weight"][year] +=
          fdq_["landings_weight_at_age"][i_age_year];

      fdq_["landings_weight"][year] +=
          fdq_["landings_weight_at_age"][i_age_year];

      pdq_["total_landings_numbers"][year] +=
          fdq_["landings_numbers_at_age"][i_age_year];

      fdq_["landings_numbers"][year] +=
          fdq_["landings_numbers_at_age"][i_age_year];
    }
  }

  /**
   * @brief Calculates weight at age of the landings for a given fleet from a
   * population.
   *
   * This function computes the expected landings at age in weight by
   * multiplying the expected landings numbers at age by the corresponding
   * weight at age:
   * \f[
   * CW_{f,a,y} = C_{f,a,y} \times w_a
   * \f]
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_year
   * @snippet{doc} this param_age
   */
  void CalculateLandingsWeightAA(
      std::shared_ptr<fims_popdy::Population<Type>> &population, size_t year,
      size_t age) {
    int i_age_year = year * population->n_ages + age;
    for (size_t fleet_ = 0; fleet_ < population->n_fleets; fleet_++) {
      std::map<std::string, fims::Vector<Type>> &fdq_ =
          this->GetFleetDerivedQuantities(population->fleets[fleet_]->GetId());

      fdq_["landings_weight_at_age"][i_age_year] =
          fdq_["landings_numbers_at_age"][i_age_year] *
          population->growth->evaluate(year,population->ages[age]);
    }
  }

  /**
   * @brief Calculates numbers of fish for the landings for a given fleet from a
   * population, year and age.
   *
   * This function uses the Baranov Catch Equation to calculate expected
   * landings in numbers at age for each fleet. With F multiplier \f$f_y\f$:
   * \f[
   * C_{f,a,y} = \frac{F_{f,y} \times f_y \times S_f(a)}{Z_{a,y}} \times N_{a,y}
   * \times
   * \left( 1 - \exp(-Z_{a,y}) \right)
   * \f]
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_i_age_year
   * @snippet{doc} this param_year
   * @snippet{doc} this param_age
   */
  void CalculateLandingsNumbersAA(
      std::shared_ptr<fims_popdy::Population<Type>> &population,
      size_t i_age_year, size_t year, size_t age) {
    std::map<std::string, fims::Vector<Type>> &pdq_ =
        this->GetPopulationDerivedQuantities(population->GetId());

    for (size_t fleet_ = 0; fleet_ < population->n_fleets; fleet_++) {
      std::map<std::string, fims::Vector<Type>> &fdq_ =
          this->GetFleetDerivedQuantities(population->fleets[fleet_]->GetId());

      // Baranov Catch Equation
      fdq_["landings_numbers_at_age"][i_age_year] +=
          (population->fleets[fleet_]->Fmort[year] *
           population->f_multiplier[year] *
           population->fleets[fleet_]->selectivity->evaluate(
               population->ages[age],year)) /
          pdq_["mortality_Z"][i_age_year] * pdq_["numbers_at_age"][i_age_year] *
          (1 - fims_math::exp(-(pdq_["mortality_Z"][i_age_year])));
    }
  }

  /**
   * @brief Calculates the index for a fleet from a population.
   *
   * This function updates the population indices for each fleet by adding the
   * age- and year-specific index weights and numbers to the corresponding
   * annual totals. The updated index weight and index numbers for a given
   * fleet and year are calculated as:
   * \f[
   * IW_{f,y} \mathrel{+}= IWAA_{a,y}, \quad
   * IN_{f,y} \mathrel{+}= INAA_{a,y}
   * \f]
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_i_age_year
   * @snippet{doc} this param_year
   * @snippet{doc} this param_age
   */
  void CalculateIndex(std::shared_ptr<fims_popdy::Population<Type>> &population,
                      size_t i_age_year, size_t year, size_t age) {
    for (size_t fleet_ = 0; fleet_ < population->n_fleets; fleet_++) {
      std::map<std::string, fims::Vector<Type>> &fdq_ =
          this->GetFleetDerivedQuantities(population->fleets[fleet_]->GetId());

      fdq_["index_weight"][year] += fdq_["index_weight_at_age"][i_age_year];

      fdq_["index_numbers"][year] += fdq_["index_numbers_at_age"][i_age_year];
    }
  }

  /**
   * @brief Calculates the numbers for the index for a fleet from a population.
   *
   * This function calculates the expected index in numbers at age for each
   * fleet, using catchability, selectivity, and population numbers at age:
   * \f[
   * IN_{f,a,y} \mathrel{+}= q_{f,y} \times S_f(a) \times N_{a,y}
   * \f]
   *
   * When timing is accounted for within FIMS the equation will include the
   * fraction of the year when the survey was conducted \f$t_y\f$:
   * \f[ IN_{f,a,y} \mathrel{+}= S_{f,y}(a) \times N_{a,y} \times
   * e^{(-t_{y}Z_{a,y})}\f]
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_i_age_year
   * @snippet{doc} this param_year
   * @snippet{doc} this param_age
   */
  void CalculateIndexNumbersAA(
      std::shared_ptr<fims_popdy::Population<Type>> &population,
      size_t i_age_year, size_t year, size_t age) {
    std::map<std::string, fims::Vector<Type>> &pdq_ =
        this->GetPopulationDerivedQuantities(population->GetId());

    for (size_t fleet_ = 0; fleet_ < population->n_fleets; fleet_++) {
      std::map<std::string, fims::Vector<Type>> &fdq_ =
          this->GetFleetDerivedQuantities(population->fleets[fleet_]->GetId());

      fdq_["index_numbers_at_age"][i_age_year] +=
          (population->fleets[fleet_]->q.get_force_scalar(year) *
           population->fleets[fleet_]->selectivity->evaluate(
               population->ages[age],year)) *
          pdq_["numbers_at_age"][i_age_year];
    }
  }

  /**
   * @brief Calculates biomass of fish for the index for a given fleet from a
   * population.
   *
   * This function computes the expected index weight at age by multiplying the
   * expected index numbers at age by the corresponding weight at age:
   * \f[
   * IWAA_{f,a,y} = IN_{f,a,y} \times w_a
   * \f]
   *
   * @snippet{doc} this param_population
   * @snippet{doc} this param_year
   * @snippet{doc} this param_age
   */
  void CalculateIndexWeightAA(
      std::shared_ptr<fims_popdy::Population<Type>> &population, size_t year,
      size_t age) {
    int i_age_year = year * population->n_ages + age;
    for (size_t fleet_ = 0; fleet_ < population->n_fleets; fleet_++) {
      std::map<std::string, fims::Vector<Type>> &fdq_ =
          this->GetFleetDerivedQuantities(population->fleets[fleet_]->GetId());

      fdq_["index_weight_at_age"][i_age_year] =
          fdq_["index_numbers_at_age"][i_age_year] *
          population->growth->evaluate(year,population->ages[age]);
    }
  }

  /**
   * Evaluate the proportion of landings numbers at age.
   */
  void evaluate_age_comp() {
    fleet_iterator fit;
    for (fit = this->fleets.begin(); fit != this->fleets.end(); ++fit) {
      std::map<std::string, fims::Vector<Type>> &fdq_ =
          this->GetFleetDerivedQuantities((*fit).second->GetId());

      std::shared_ptr<fims_popdy::Fleet<Type>> &fleet = (*fit).second;
      for (size_t y = 0; y < fleet->n_years; y++) {
        Type sum = static_cast<Type>(0.0);
        Type sum_obs = static_cast<Type>(0.0);
        // robust_add is a small value to add to expected composition
        // proportions at age to stabilize likelihood calculations
        // when the expected proportions are close to zero.
        // Type robust_add = static_cast<Type>(0.0); // zeroed out before
        // testing 0.0001; sum robust is used to calculate the total sum of
        // robust additions to ensure that proportions sum to 1. Type robust_sum
        // = static_cast<Type>(1.0);

        for (size_t a = 0; a < fleet->n_ages; a++) {
          size_t i_age_year = y * fleet->n_ages + a;
          // Here we have a check to determine if the age comp
          // should be calculated from the retained landings or
          // the total population. These values are slightly different.
          // In the future this will have more impact as we implement
          // timing rather than everything occurring at the start of
          // the year.
          if (fleet->fleet_observed_landings_data_id_m == -999) {
            fdq_["agecomp_expected"][i_age_year] =
                fdq_["index_numbers_at_age"][i_age_year];
          } else {
            fdq_["agecomp_expected"][i_age_year] =
                fdq_["landings_numbers_at_age"][i_age_year];
          }
          sum += fdq_["agecomp_expected"][i_age_year];
          // robust_sum -= robust_add;

          // This sums over the observed age composition data so that
          // the expected age composition can be rescaled to match the
          // total number observed. The check for na values should not
          // be needed as individual years should not have missing data.
          // This is need to be re-explored if/when we modify FIMS to
          // allow for composition bins that do not match the population
          // bins.
          if (fleet->fleet_observed_agecomp_data_id_m != -999) {
            if (fleet->observed_agecomp_data->at(i_age_year) !=
                fleet->observed_agecomp_data->na_value) {
              sum_obs += fleet->observed_agecomp_data->at(i_age_year);
            }
          }
        }
        for (size_t a = 0; a < fleet->n_ages; a++) {
          size_t i_age_year = y * fleet->n_ages + a;
          fdq_["agecomp_proportion"][i_age_year] =
              fdq_["agecomp_expected"][i_age_year] / sum;
          // robust_add + robust_sum * this->agecomp_expected[i_age_year] / sum;

          if (fleet->fleet_observed_agecomp_data_id_m != -999) {
            fdq_["agecomp_expected"][i_age_year] =
                fdq_["agecomp_proportion"][i_age_year] * sum_obs;
          }
        }
      }
    }
  }

  /**
   * Evaluate the proportion of landings numbers at length.
   */
  void evaluate_length_comp() {
    fleet_iterator fit;
    for (fit = this->fleets.begin(); fit != this->fleets.end(); ++fit) {
      std::map<std::string, fims::Vector<Type>> &fdq_ =
          this->GetFleetDerivedQuantities((*fit).second->GetId());

      std::shared_ptr<fims_popdy::Fleet<Type>> &fleet = (*fit).second;

      if (fleet->n_lengths > 0) {
        for (size_t y = 0; y < fleet->n_years; y++) {
          Type sum = static_cast<Type>(0.0);
          Type sum_obs = static_cast<Type>(0.0);
          // robust_add is a small value to add to expected composition
          // proportions at age to stabilize likelihood calculations
          // when the expected proportions are close to zero.
          // Type robust_add = static_cast<Type>(0.0); // 0.0001; zeroed out
          // before testing sum robust is used to calculate the total sum of
          // robust additions to ensure that proportions sum to 1. Type
          // robust_sum = static_cast<Type>(1.0);
          for (size_t l = 0; l < fleet->n_lengths; l++) {
            size_t i_length_year = y * fleet->n_lengths + l;
            for (size_t a = 0; a < fleet->n_ages; a++) {
              size_t i_age_year = y * fleet->n_ages + a;
              size_t i_length_age = a * fleet->n_lengths + l;
              fdq_["lengthcomp_expected"][i_length_year] +=
                  fdq_["agecomp_expected"][i_age_year] *
                  fleet->age_to_length_conversion[i_length_age];

              fdq_["landings_numbers_at_length"][i_length_year] +=
                  fdq_["landings_numbers_at_age"][i_age_year] *
                  fleet->age_to_length_conversion[i_length_age];

              fdq_["index_numbers_at_length"][i_length_year] +=
                  fdq_["index_numbers_at_age"][i_age_year] *
                  fleet->age_to_length_conversion[i_length_age];
            }

            sum += fdq_["lengthcomp_expected"][i_length_year];
            // robust_sum -= robust_add;

            if (fleet->fleet_observed_lengthcomp_data_id_m != -999) {
              if (fleet->observed_lengthcomp_data->at(i_length_year) !=
                  fleet->observed_lengthcomp_data->na_value) {
                sum_obs += fleet->observed_lengthcomp_data->at(i_length_year);
              }
            }
          }
          for (size_t l = 0; l < fleet->n_lengths; l++) {
            size_t i_length_year = y * fleet->n_lengths + l;
            fdq_["lengthcomp_proportion"][i_length_year] =
                fdq_["lengthcomp_expected"][i_length_year] / sum;
            // robust_add + robust_sum *
            // this->lengthcomp_expected[i_length_year] / sum;
            if (fleet->fleet_observed_lengthcomp_data_id_m != -999) {
              fdq_["lengthcomp_expected"][i_length_year] =
                  fdq_["lengthcomp_proportion"][i_length_year] * sum_obs;
            }
          }
        }
      }
    }
  }

  /**
   * Evaluate the natural log of the expected index.
   */
  void evaluate_index() {
    fleet_iterator fit;
    for (fit = this->fleets.begin(); fit != this->fleets.end(); ++fit) {
      std::map<std::string, fims::Vector<Type>> &fdq_ =
          this->GetFleetDerivedQuantities((*fit).second->GetId());
      std::shared_ptr<fims_popdy::Fleet<Type>> &fleet = (*fit).second;

      for (size_t i = 0; i < fdq_["index_numbers"].size(); i++) {
        if (fleet->observed_index_units == "number") {
          fdq_["index_expected"][i] = fdq_["index_numbers"][i];
        } else {
          fdq_["index_expected"][i] = fdq_["index_weight"][i];
        }
        fdq_["log_index_expected"][i] = log(fdq_["index_expected"][i]);
      }
    }
  }

  /**
   * Evaluate the natural log of the expected landings.
   */
  void evaluate_landings() {
    fleet_iterator fit;
    for (fit = this->fleets.begin(); fit != this->fleets.end(); ++fit) {
      std::map<std::string, fims::Vector<Type>> &fdq_ =
          this->GetFleetDerivedQuantities((*fit).second->GetId());
      std::shared_ptr<fims_popdy::Fleet<Type>> &fleet = (*fit).second;

      for (size_t i = 0; i < fdq_["landings_weight"].size(); i++) {
        if (fleet->observed_landings_units == "number") {
          fdq_["landings_expected"][i] = fdq_["landings_numbers"][i];
        } else {
          fdq_["landings_expected"][i] = fdq_["landings_weight"][i];
        }
        fdq_["log_landings_expected"][i] = log(fdq_["landings_expected"][i]);
      }
    }
  }

  virtual void Evaluate() {
    /*
               Sets derived vectors to zero
               Performs parameters transformations
               Sets recruitment deviations to mean 0.
     */
    Prepare();
    /*
     start at year=0, age=0;
     here year 0 is the estimated initial population structure and age 0 are
     recruits loops start at zero with if statements inside to specify unique
     code for initial structure and recruitment 0 loops. Could also have started
     loops at 1 with initial structure and recruitment setup outside the loops.

     year loop is extended to <= n_years because SSB is calculated as the start
     of the year value and by extending one extra year we get estimates of the
     population structure at the end of the final year. An alternative approach
     would be to keep initial numbers at age in it's own vector and each year to
     include the population structure at the end of the year. This is likely a
     null point given that we are planning to modify to an event/stanza based
     structure in later milestones which will eliminate this confusion by
     explicitly referencing the exact date (or period of averaging) at which any
     calculation or output is being made.
     */
    for (size_t p = 0; p < this->populations.size(); p++) {
      std::shared_ptr<fims_popdy::Population<Type>> &population =
          this->populations[p];
      std::map<std::string, fims::Vector<Type>> &pdq_ =
          this->GetPopulationDerivedQuantities(population->GetId());
      // CAAPopulationProxy<Type>& population = this->populations_proxies[p];

      for (size_t y = 0; y <= population->n_years; y++) {
        for (size_t a = 0; a < population->n_ages; a++) {
          /*
           index naming defines the dimensional folding structure
           i.e. i_age_year is referencing folding over years and ages.
           */
          size_t i_age_year = y * population->n_ages + a;
          /*
           Mortality rates are not estimated in the final year which is
           used to show expected population structure at the end of the model
           period. This is because biomass in year i represents biomass at the
           start of the year. Should we add complexity to track more values such
           as start, mid, and end biomass in all years where, start biomass=end
           biomass of the previous year? Referenced above, this is probably not
           worth exploring as later milestone changes will eliminate this
           confusion.
           */
          if (y < population->n_years) {
            /*
             First thing we need is total mortality aggregated across all fleets
             to inform the subsequent catch and change in numbers at age
             calculations. This is only calculated for years < n_years as these
             are the model estimated years with data. The year loop extends to
             y=n_years so that population numbers at age and SSB can be
             calculated at the end of the last year of the model
             */
            CalculateMortality(population, i_age_year, y, a);
          }
          CalculateMaturityAA(population, i_age_year, a);
          /* if statements needed because some quantities are only needed
          for the first year and/or age, so these steps are included here.
           */
          if (y == 0) {
            // Initial numbers at age is a user input or estimated parameter
            // vector.
            CalculateInitialNumbersAA(population, i_age_year, a);

            if (a == 0) {
              /*
             Expected recruitment in year 0 is numbers at age 0 in year 0.
             */
              pdq_["expected_recruitment"][y] =
                  pdq_["numbers_at_age"][i_age_year];
              pdq_["unfished_numbers_at_age"][i_age_year] =
                  fims_math::exp(population->recruitment->log_rzero[0]);
            } else {
              CalculateUnfishedNumbersAA(population, i_age_year, a - 1, a);
            }

          } else {
            if (a == 0) {
              // Set the nrecruits for age a=0 year y (use pointers instead of
              // functional returns) assuming fecundity = 1 and 50:50 sex ratio
              CalculateRecruitment(population, i_age_year, y, y);
              pdq_["unfished_numbers_at_age"][i_age_year] =
                  fims_math::exp(population->recruitment->log_rzero[0]);
            } else {
              size_t i_agem1_yearm1 = (y - 1) * population->n_ages + (a - 1);
              CalculateNumbersAA(population, i_age_year, i_agem1_yearm1, a);
              CalculateUnfishedNumbersAA(population, i_age_year, i_agem1_yearm1,
                                         a);
            }
          }

          /*
            Fished and unfished biomass vectors are summing biomass at
            age across ages.
          */

          CalculateBiomass(population, i_age_year, y, a);

          CalculateUnfishedBiomass(population, i_age_year, y, a);

          /*
            Fished and unfished spawning biomass vectors are summing biomass at
            age across ages to allow calculation of recruitment in the next
            year.
          */

          CalculateSpawningBiomass(population, i_age_year, y, a);

          CalculateUnfishedSpawningBiomass(population, i_age_year, y, a);

          /*
          Here composition, total catch, and index values are calculated for all
          years with reference data. They are not calculated for y=n_years as
          there is this is just to get final population structure at the end of
          the terminal year.
           */
          if (y < population->n_years) {
            CalculateLandingsNumbersAA(population, i_age_year, y, a);
            CalculateLandingsWeightAA(population, y, a);
            CalculateLandings(population, y, a);

            CalculateIndexNumbersAA(population, i_age_year, y, a);
            CalculateIndexWeightAA(population, y, a);
            CalculateIndex(population, i_age_year, y, a);
          }
        }
        /* Calculate spawning biomass depletion ratio */
        CalculateSpawningBiomassRatio(population, y);
      }
    }
    evaluate_age_comp();
    evaluate_length_comp();
    evaluate_index();
    evaluate_landings();
  }
  /**
   * * This method is used to generate TMB reports from the population dynamics
   * model.
   */
  virtual void Report() {
    int n_fleets = this->fleets.size();
    int n_pops = this->populations.size();
#ifdef TMB_MODEL
    if (this->do_reporting == true) {
      report_vectors.clear();
      // initialize population vectors
      vector<vector<Type>> biomass_p(n_pops);
      vector<vector<Type>> expected_recruitment_p(n_pops);
      vector<vector<Type>> mortality_F_p(n_pops);
      vector<vector<Type>> mortality_M_p(n_pops);
      vector<vector<Type>> mortality_Z_p(n_pops);
      vector<vector<Type>> numbers_at_age_p(n_pops);
      vector<vector<Type>> proportion_mature_at_age_p(n_pops);
      vector<vector<Type>> spawning_biomass_p(n_pops);
      vector<vector<Type>> sum_selectivity_p(n_pops);
      vector<vector<Type>> total_landings_numbers_p(n_pops);
      vector<vector<Type>> total_landings_weight_p(n_pops);
      vector<vector<Type>> unfished_biomass_p(n_pops);
      vector<vector<Type>> unfished_numbers_at_age_p(n_pops);
      vector<vector<Type>> unfished_spawning_biomass_p(n_pops);
      vector<vector<Type>> spawning_biomass_ratio_p(n_pops);

      // initialize fleet vectors
      vector<vector<Type>> agecomp_expected_f(n_fleets);
      vector<vector<Type>> agecomp_proportion_f(n_fleets);
      vector<vector<Type>> catch_index_f(n_fleets);
      vector<vector<Type>> index_expected_f(n_fleets);
      vector<vector<Type>> index_numbers_f(n_fleets);
      vector<vector<Type>> index_numbers_at_age_f(n_fleets);
      vector<vector<Type>> index_numbers_at_length_f(n_fleets);
      vector<vector<Type>> index_weight_f(n_fleets);
      vector<vector<Type>> index_weight_at_age_f(n_fleets);
      vector<vector<Type>> landings_expected_f(n_fleets);
      vector<vector<Type>> landings_numbers_f(n_fleets);
      vector<vector<Type>> landings_numbers_at_age_f(n_fleets);
      vector<vector<Type>> landings_numbers_at_length_f(n_fleets);
      vector<vector<Type>> landings_weight_f(n_fleets);
      vector<vector<Type>> landings_weight_at_age_f(n_fleets);
      vector<vector<Type>> lengthcomp_expected_f(n_fleets);
      vector<vector<Type>> lengthcomp_proportion_f(n_fleets);
      vector<vector<Type>> log_index_expected_f(n_fleets);
      vector<vector<Type>> log_landings_expected_f(n_fleets);

      // initiate population index for structuring report out objects
      int pop_idx = 0;
      for (size_t p = 0; p < this->populations.size(); p++) {
        std::map<std::string, fims::Vector<Type>> &derived_quantities =
            this->GetPopulationDerivedQuantities(this->populations[p]->GetId());
        biomass_p(pop_idx) = derived_quantities["biomass"].to_tmb();
        expected_recruitment_p(pop_idx) =
            derived_quantities["expected_recruitment"].to_tmb();
        mortality_F_p(pop_idx) = derived_quantities["mortality_F"].to_tmb();
        mortality_M_p(pop_idx) = derived_quantities["mortality_M"].to_tmb();
        mortality_Z_p(pop_idx) = derived_quantities["mortality_Z"].to_tmb();
        numbers_at_age_p(pop_idx) =
            derived_quantities["numbers_at_age"].to_tmb();
        proportion_mature_at_age_p(pop_idx) =
            derived_quantities["proportion_mature_at_age"].to_tmb();
        spawning_biomass_p(pop_idx) =
            derived_quantities["spawning_biomass"].to_tmb();
        sum_selectivity_p(pop_idx) =
            derived_quantities["sum_selectivity"].to_tmb();
        total_landings_numbers_p(pop_idx) =
            derived_quantities["total_landings_numbers"].to_tmb();
        total_landings_weight_p(pop_idx) =
            derived_quantities["total_landings_weight"].to_tmb();
        unfished_biomass_p(pop_idx) =
            derived_quantities["unfished_biomass"].to_tmb();
        unfished_numbers_at_age_p(pop_idx) =
            derived_quantities["unfished_numbers_at_age"].to_tmb();
        unfished_spawning_biomass_p(pop_idx) =
            derived_quantities["unfished_spawning_biomass"].to_tmb();
        spawning_biomass_ratio_p(pop_idx) =
            this->populations[pop_idx]->spawning_biomass_ratio.to_tmb();

        pop_idx += 1;
      }

      // initiate fleet index for structuring report out objects
      int fleet_idx = 0;
      fleet_iterator fit;
      for (fit = this->fleets.begin(); fit != this->fleets.end(); ++fit) {
        std::shared_ptr<fims_popdy::Fleet<Type>> &fleet = (*fit).second;
        std::map<std::string, fims::Vector<Type>> &derived_quantities =
            this->GetFleetDerivedQuantities(fleet->GetId());

        agecomp_expected_f(fleet_idx) =
            derived_quantities["agecomp_expected"].to_tmb();
        agecomp_proportion_f(fleet_idx) =
            derived_quantities["agecomp_proportion"].to_tmb();
        catch_index_f(fleet_idx) = derived_quantities["catch_index"].to_tmb();
        index_expected_f(fleet_idx) =
            derived_quantities["index_expected"].to_tmb();
        index_numbers_f(fleet_idx) =
            derived_quantities["index_numbers"].to_tmb();
        index_numbers_at_age_f(fleet_idx) =
            derived_quantities["index_numbers_at_age"].to_tmb();
        index_numbers_at_length_f(fleet_idx) =
            derived_quantities["index_numbers_at_length"].to_tmb();
        index_weight_f(fleet_idx) = derived_quantities["index_weight"].to_tmb();
        index_weight_at_age_f(fleet_idx) =
            derived_quantities["index_weight_at_age"].to_tmb();
        landings_expected_f(fleet_idx) =
            derived_quantities["landings_expected"].to_tmb();
        landings_numbers_f(fleet_idx) =
            derived_quantities["landings_numbers"].to_tmb();
        landings_numbers_at_age_f(fleet_idx) =
            derived_quantities["landings_numbers_at_age"].to_tmb();
        landings_numbers_at_length_f(fleet_idx) =
            derived_quantities["landings_numbers_at_length"].to_tmb();
        landings_weight_f(fleet_idx) =
            derived_quantities["landings_weight"].to_tmb();
        landings_weight_at_age_f(fleet_idx) =
            derived_quantities["landings_weight_at_age"].to_tmb();
        // length_comp_expected_f(fleet_idx) =
        // derived_quantities["length_comp_expected"];
        // length_comp_proportion_f(fleet_idx) =
        // derived_quantities["length_comp_proportion"];
        lengthcomp_expected_f(fleet_idx) =
            derived_quantities["lengthcomp_expected"].to_tmb();
        lengthcomp_proportion_f(fleet_idx) =
            derived_quantities["lengthcomp_proportion"].to_tmb();
        log_index_expected_f(fleet_idx) =
            derived_quantities["log_index_expected"].to_tmb();
        log_landings_expected_f(fleet_idx) =
            derived_quantities["log_landings_expected"].to_tmb();
        fleet_idx += 1;
      }

      vector<Type> biomass = ADREPORTvector(biomass_p);
      vector<Type> expected_recruitment =
          ADREPORTvector(expected_recruitment_p);
      vector<Type> mortality_F = ADREPORTvector(mortality_F_p);
      vector<Type> mortality_M = ADREPORTvector(mortality_M_p);
      vector<Type> mortality_Z = ADREPORTvector(mortality_Z_p);
      vector<Type> numbers_at_age = ADREPORTvector(numbers_at_age_p);
      vector<Type> proportion_mature_at_age =
          ADREPORTvector(proportion_mature_at_age_p);
      vector<Type> spawning_biomass = ADREPORTvector(spawning_biomass_p);
      vector<Type> sum_selectivity = ADREPORTvector(sum_selectivity_p);
      vector<Type> total_landings_numbers =
          ADREPORTvector(total_landings_numbers_p);
      vector<Type> total_landings_weight =
          ADREPORTvector(total_landings_weight_p);
      vector<Type> unfished_biomass = ADREPORTvector(unfished_biomass_p);
      vector<Type> unfished_numbers_at_age =
          ADREPORTvector(unfished_numbers_at_age_p);
      vector<Type> unfished_spawning_biomass =
          ADREPORTvector(unfished_spawning_biomass_p);
      vector<Type> spawning_biomass_ratio =
          ADREPORTvector(spawning_biomass_ratio_p);

      vector<Type> agecomp_expected = ADREPORTvector(agecomp_expected_f);
      vector<Type> agecomp_proportion = ADREPORTvector(agecomp_proportion_f);
      vector<Type> catch_index = ADREPORTvector(catch_index_f);
      vector<Type> index_expected = ADREPORTvector(index_expected_f);
      vector<Type> index_numbers = ADREPORTvector(index_numbers_f);
      vector<Type> index_numbers_at_age =
          ADREPORTvector(index_numbers_at_age_f);
      vector<Type> index_numbers_at_length =
          ADREPORTvector(index_numbers_at_length_f);
      vector<Type> index_weight = ADREPORTvector(index_weight_f);
      vector<Type> index_weight_at_age = ADREPORTvector(index_weight_at_age_f);
      vector<Type> landings_expected = ADREPORTvector(landings_expected_f);
      vector<Type> landings_numbers = ADREPORTvector(landings_numbers_f);
      vector<Type> landings_numbers_at_age =
          ADREPORTvector(landings_numbers_at_age_f);
      vector<Type> landings_numbers_at_length =
          ADREPORTvector(landings_numbers_at_length_f);
      vector<Type> landings_weight = ADREPORTvector(landings_weight_f);
      vector<Type> landings_weight_at_age =
          ADREPORTvector(landings_weight_at_age_f);
      // vector<Type> length_comp_expected =
      // ADREPORTvector(length_comp_expected_f); vector<Type>
      // length_comp_proportion = ADREPORTvector(length_comp_proportion_f);
      vector<Type> lengthcomp_expected = ADREPORTvector(lengthcomp_expected_f);
      vector<Type> lengthcomp_proportion =
          ADREPORTvector(lengthcomp_proportion_f);
      vector<Type> log_index_expected = ADREPORTvector(log_index_expected_f);
      vector<Type> log_landings_expected =
          ADREPORTvector(log_landings_expected_f);
      // populations
      // report
      FIMS_REPORT_F_("biomass", biomass_p, this->of);
      FIMS_REPORT_F_("expected_recruitment", expected_recruitment_p, this->of);
      FIMS_REPORT_F_("mortality_F", mortality_F_p, this->of);
      FIMS_REPORT_F_("mortality_M", mortality_M_p, this->of);
      FIMS_REPORT_F_("mortality_Z", mortality_Z_p, this->of);
      FIMS_REPORT_F_("numbers_at_age", numbers_at_age_p, this->of);
      FIMS_REPORT_F_("proportion_mature_at_age", proportion_mature_at_age_p,
                     this->of);
      FIMS_REPORT_F_("spawning_biomass", spawning_biomass_p, this->of);
      FIMS_REPORT_F_("sum_selectivity", sum_selectivity_p, this->of);
      FIMS_REPORT_F_("total_landings_numbers", total_landings_numbers_p,
                     this->of);
      FIMS_REPORT_F_("total_landings_weight", total_landings_weight_p,
                     this->of);
      FIMS_REPORT_F_("unfished_biomass", unfished_biomass_p, this->of);
      FIMS_REPORT_F_("unfished_numbers_at_age", unfished_numbers_at_age_p,
                     this->of);
      FIMS_REPORT_F_("unfished_spawning_biomass", unfished_spawning_biomass_p,
                     this->of);
      FIMS_REPORT_F_("spawning_biomass_ratio", spawning_biomass_ratio_p,
                     this->of);

      // adreport
      ADREPORT_F(biomass, this->of);
      ADREPORT_F(expected_recruitment, this->of);
      ADREPORT_F(mortality_F, this->of);
      ADREPORT_F(mortality_M, this->of);
      ADREPORT_F(mortality_Z, this->of);
      ADREPORT_F(numbers_at_age, this->of);
      ADREPORT_F(proportion_mature_at_age, this->of);
      ADREPORT_F(spawning_biomass, this->of);
      ADREPORT_F(sum_selectivity, this->of);
      ADREPORT_F(total_landings_numbers, this->of);
      ADREPORT_F(total_landings_weight, this->of);
      ADREPORT_F(unfished_biomass, this->of);
      ADREPORT_F(unfished_numbers_at_age, this->of);
      ADREPORT_F(unfished_spawning_biomass, this->of);
      ADREPORT_F(spawning_biomass_ratio, this->of);

      // fleets
      // report
      FIMS_REPORT_F_("agecomp_expected", agecomp_expected_f, this->of);
      FIMS_REPORT_F_("agecomp_proportion", agecomp_proportion_f, this->of);
      FIMS_REPORT_F_("catch_index", catch_index_f, this->of);
      FIMS_REPORT_F_("index_expected", index_expected_f, this->of);
      FIMS_REPORT_F_("index_numbers", index_numbers_f, this->of);
      FIMS_REPORT_F_("index_numbers_at_age", index_numbers_at_age_f, this->of);
      FIMS_REPORT_F_("index_numbers_at_length", index_numbers_at_length_f,
                     this->of);
      FIMS_REPORT_F_("index_weight", index_weight_f, this->of);
      FIMS_REPORT_F_("index_weight_at_age", index_weight_at_age_f, this->of);
      FIMS_REPORT_F_("landings_expected", landings_expected_f, this->of);
      FIMS_REPORT_F_("landings_numbers", landings_numbers_f, this->of);
      FIMS_REPORT_F_("landings_numbers_at_age", landings_numbers_at_age_f,
                     this->of);
      FIMS_REPORT_F_("landings_numbers_at_length", landings_numbers_at_length_f,
                     this->of);
      FIMS_REPORT_F_("landings_weight", landings_weight_f, this->of);
      FIMS_REPORT_F_("landings_weight_at_age", landings_weight_at_age_f,
                     this->of);
      FIMS_REPORT_F_("lengthcomp_expected", lengthcomp_expected_f, this->of);
      FIMS_REPORT_F_("lengthcomp_proportion", lengthcomp_proportion_f,
                     this->of);
      FIMS_REPORT_F_("log_index_expected", log_index_expected_f, this->of);
      FIMS_REPORT_F_("log_landings_expected", log_landings_expected_f,
                     this->of);
      // adreport
      ADREPORT_F(agecomp_expected, this->of);
      ADREPORT_F(agecomp_proportion, this->of);
      ADREPORT_F(catch_index, this->of);
      ADREPORT_F(index_expected, this->of);
      ADREPORT_F(index_numbers, this->of);
      ADREPORT_F(index_numbers_at_age, this->of);
      ADREPORT_F(index_numbers_at_length, this->of);
      ADREPORT_F(index_weight, this->of);
      ADREPORT_F(index_weight_at_age, this->of);
      ADREPORT_F(landings_expected, this->of);
      ADREPORT_F(landings_numbers, this->of);
      ADREPORT_F(landings_numbers_at_age, this->of);
      ADREPORT_F(landings_numbers_at_length, this->of);
      ADREPORT_F(landings_weight, this->of);
      ADREPORT_F(landings_weight_at_age, this->of);
      ADREPORT_F(lengthcomp_expected, this->of);
      ADREPORT_F(lengthcomp_proportion, this->of);
      ADREPORT_F(log_index_expected, this->of);
      ADREPORT_F(log_landings_expected, this->of);
      std::stringstream var_name;
      typename std::map<std::string, fims::Vector<fims::Vector<Type>>>::iterator
          rvit;
      for (rvit = report_vectors.begin(); rvit != report_vectors.end();
           ++rvit) {
        auto &x = rvit->second;

        int outer_dim = x.size();
        int dim = 0;
        for (int i = 0; i < outer_dim; i++) {
          dim += x[i].size();
        }
        vector<Type> res(dim);
        int idx = 0;
        for (int i = 0; i < outer_dim; i++) {
          int inner_dim = x[i].size();
          for (int j = 0; j < inner_dim; j++) {
            res(idx) = x[i][j];
            idx += 1;
          }
        }
        this->of->reportvector.push(res, rvit->first.c_str());
      }
    }
#endif
  }
};

}  // namespace fims_popdy

#endif

/**
 * @file fishery_model_base.hpp
 * @brief Defines the base class for all fishery models within the FIMS
 * framework.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_MODELS_FISHERY_MODEL_BASE_HPP
#define FIMS_MODELS_FISHERY_MODEL_BASE_HPP

#include "../../common/model_object.hpp"
#include "../../common/fims_math.hpp"
#include "../../common/fims_vector.hpp"
#include "../../population_dynamics/population/population.hpp"
/**
 * @brief The population dynamics of FIMS.
 *
 */
namespace fims_popdy {

/**
 * @brief Structure to hold dimension information for derived quantities.
 */
struct DimensionInfo {
  std::string name;                    /*!< name of the derived quantity */
  int ndims;                           /*!< number of dimensions */
  fims::Vector<int> dims;              /*!< vector of dimensions */
  fims::Vector<std::string> dim_names; /*!< vector of dimension names */
  fims::Vector<double> se_values_m;    /*!< final values of the report vector */

  /**
   * @brief Default constructor for dimension information.
   */
  DimensionInfo() : ndims(0) {}

  /**
   * @brief Constructor with parameters.
   * @param name The name of the derived quantity.
   * @param dims A vector of integers representing the dimensions.
   * @param dim_names A vector of strings representing the names of the
   * dimensions.
   */
  DimensionInfo(const std::string &name, const fims::Vector<int> &dims,
                const fims::Vector<std::string> &dim_names)
      : name(name), ndims(dims.size()), dims(dims), dim_names(dim_names) {}

  /**
   * Copy constructor
   */
  DimensionInfo(const DimensionInfo &other)
      : name(other.name),
        ndims(other.dims.size()),
        dims(other.dims),
        dim_names(other.dim_names) {}

  /**
   * @brief Assignment operator for DimensionInfo.
   */
  DimensionInfo &operator=(const DimensionInfo &other) {
    if (this != &other) {
      name = other.name;
      ndims = other.ndims;
      dims = other.dims;
      dim_names = other.dim_names;
      se_values_m = other.se_values_m;
    }
    return *this;
  }
};

/**
 * @brief FisheryModelBase is a base class for fishery models in FIMS.
 *
 */
template <typename Type>
class FisheryModelBase : public fims_model_object::FIMSObject<Type> {
  static uint32_t id_g; /*!< global id where unique id is drawn from for fishery
                           model object*/
  uint32_t id; /*!< unique identifier assigned for fishery model object */

 public:
#ifdef TMB_MODEL
  bool do_reporting =
      true; /*!< flag to control reporting of derived quantities */
#endif
  /**
   * @brief A string specifying the model type.
   *
   */
  std::string model_type_m;
  /**
   * @brief Unique identifier for the fishery model.
   *
   */
  std::set<uint32_t> population_ids;
  /**
   * @brief A vector of populations in the fishery model.
   *
   */
  std::vector<std::shared_ptr<fims_popdy::Population<Type>>> populations;
  /**
   * @brief A map of fleets in the fishery model, indexed by fleet id.
   * Unique instances to eliminate duplicate initialization.
   *
   */
  std::map<uint32_t, std::shared_ptr<fims_popdy::Fleet<Type>>> fleets;
  /**
   * @brief Fleet-based iterator.
   *
   */
  typedef typename std::map<uint32_t,
                            std::shared_ptr<fims_popdy::Fleet<Type>>>::iterator
      fleet_iterator;

  /**
   * @brief Type definitions for derived quantities and dimension information
   * maps.
   */
  typedef typename std::map<uint32_t, std::map<std::string, fims::Vector<Type>>>
      DerivedQuantitiesMap;

  /**
   * @brief Iterator for the derived quantities map.
   */
  typedef typename DerivedQuantitiesMap::iterator DerivedQuantitiesMapIterator;

  /**
   * @brief Shared pointer for the fleet derived quantities map.
   */
  std::shared_ptr<DerivedQuantitiesMap> fleet_derived_quantities;

  /**
   * @brief Shared pointer for the population derived quantities map.
   */
  std::shared_ptr<DerivedQuantitiesMap> population_derived_quantities;

  /**
   * @brief Type definitions for dimension information maps.
   */
  typedef typename std::map<uint32_t, std::map<std::string, DimensionInfo>>
      DimensionInfoMap;

  /**
   * @brief Shared pointer for the fleet dimension information map.
   */
  std::shared_ptr<DimensionInfoMap> fleet_dimension_info;

  /**
   * @brief Shared pointer for the population dimension information map.
   */
  std::shared_ptr<DimensionInfoMap> population_dimension_info;

#ifdef TMB_MODEL
  ::objective_function<Type> *of;
#endif
  /**
   * @brief Construct a new Fishery Model Base object.
   *
   */
  FisheryModelBase() : id(FisheryModelBase::id_g++) {
    fleet_derived_quantities = std::make_shared<DerivedQuantitiesMap>();
    population_derived_quantities = std::make_shared<DerivedQuantitiesMap>();
    fleet_dimension_info = std::make_shared<DimensionInfoMap>();
    population_dimension_info = std::make_shared<DimensionInfoMap>();
  }

  /**
   * @brief Construct a new Fishery Model Base object.
   *
   * @param other
   */
  FisheryModelBase(const FisheryModelBase &other)
      : id(other.id),
        population_ids(other.population_ids),
        populations(other.populations),
        fleet_derived_quantities(other.fleet_derived_quantities),
        population_derived_quantities(other.population_derived_quantities),
        fleet_dimension_info(other.fleet_dimension_info),
        population_dimension_info(other.population_dimension_info) {}

  /**
   * @brief Destroy the Fishery Model Base object.
   *
   */
  virtual ~FisheryModelBase() {}

  /**
   * @brief Get the fleet dimension information.
   *
   * @return std::map<uint32_t, std::map<std::string, DimensionInfo>>
   */
  std::map<uint32_t, std::map<std::string, DimensionInfo>> &
  GetFleetDimensionInfo() {
    return *fleet_dimension_info;
  }

  /**
   * @brief Get the population dimension information.
   *
   * @return std::map<uint32_t, std::map<std::string, DimensionInfo>>
   */
  std::map<uint32_t, std::map<std::string, DimensionInfo>> &
  GetPopulationDimensionInfo() {
    return *population_dimension_info;
  }

  /**
   * @brief Get the fleet derived quantities.
   *
   * @return DerivedQuantitiesMap
   */
  DerivedQuantitiesMap &GetFleetDerivedQuantities() {
    return *fleet_derived_quantities;
  }

  /**
   * @brief Get the population derived quantities.
   *
   * @return DerivedQuantitiesMap
   */
  DerivedQuantitiesMap &GetPopulationDerivedQuantities() {
    return *population_derived_quantities;
  }

  /**
   * @brief Get the fleet derived quantities for a specified fleet.
   *
   * @param fleet_id The ID of the fleet.
   * @return std::map<std::string, fims::Vector<Type>>&
   */
  std::map<std::string, fims::Vector<Type>> &GetFleetDerivedQuantities(
      uint32_t fleet_id) {
    if (!fleet_derived_quantities) {
      throw std::runtime_error(
          "GetFleetDerivedQuantities: fleet_derived_quantities is null");
    }
    auto &outer = *fleet_derived_quantities;
    auto it = outer.find(fleet_id);
    if (it == outer.end()) {
      std::stringstream ss;

      ss << "GetFleetDerivedQuantities: fleet_id " << fleet_id
         << " not found in fleet_derived_quantities";
      throw std::out_of_range(ss.str());
    }
    return it->second;
  }

  /**
   * @brief Initialize the derived quantities map for a fleet.
   *
   * @details Ensures the derived quantities map for the specified fleet
   * exists. If not, creates an empty map for the fleet ID.
   *
   * @param fleet_id The ID of the fleet to initialize.
   */
  void InitializeFleetDerivedQuantities(uint32_t fleet_id) {
    // Ensure the shared_ptr exists
    if (!fleet_derived_quantities) {
      fleet_derived_quantities = std::make_shared<
          std::map<uint32_t, std::map<std::string, fims::Vector<Type>>>>();
    }

    auto &outer = *fleet_derived_quantities;

    // Insert only if not already present
    if (outer.find(fleet_id) == outer.end()) {
      outer.emplace(fleet_id, std::map<std::string, fims::Vector<Type>>{});
    }
  }

  /**
   * @brief Initialize the derived quantities map for a population.
   *
   * @details Ensures the derived quantities map for the specified
   * population exists. If not, creates an empty map for the population ID.
   *
   * @param population_id The ID of the population to initialize.
   */
  void InitializePopulationDerivedQuantities(uint32_t population_id) {
    // Ensure the shared_ptr exists
    if (!population_derived_quantities) {
      population_derived_quantities = std::make_shared<
          std::map<uint32_t, std::map<std::string, fims::Vector<Type>>>>();
    }

    auto &outer = *population_derived_quantities;

    // Insert only if not already present
    if (outer.find(population_id) == outer.end()) {
      outer.emplace(population_id, std::map<std::string, fims::Vector<Type>>{});
    }
  }

  /**
   * @brief Get the population derived quantities for a specified population.
   *
   * @param population_id The ID of the population.
   * @return std::map<std::string, fims::Vector<Type>>&
   */
  std::map<std::string, fims::Vector<Type>> &GetPopulationDerivedQuantities(
      uint32_t population_id) {
    if (!population_derived_quantities) {
      throw std::runtime_error(
          "GetPopulationDerivedQuantities: population_derived_quantities is "
          "null");
    }
    auto &outer = *population_derived_quantities;
    auto it = outer.find(population_id);
    if (it == outer.end()) {
      std::ostringstream ss;
      ss << "GetPopulationDerivedQuantities: population_id " << population_id
         << " not found in population_derived_quantities";
      throw std::out_of_range(ss.str());
    }
    return it->second;
  }

  /**
   * @brief Get the fleet dimension information for a specified fleet.
   *
   * @param fleet_id The ID of the fleet.
   * @return std::map<std::string, DimensionInfo>
   */
  std::map<std::string, DimensionInfo> &GetFleetDimensionInfo(
      uint32_t fleet_id) {
    return (*fleet_dimension_info)[fleet_id];
  }

  /**
   * @brief Get the population dimension information for a specified population.
   *
   * @param population_id The ID of the population.
   * @return std::map<std::string, DimensionInfo>
   */
  std::map<std::string, DimensionInfo> &GetPopulationDimensionInfo(
      uint32_t population_id) {
    return (*population_dimension_info)[population_id];
  }

  /**
   * @brief Initialize a model.
   *
   */
  virtual void Initialize() {}

  /**
   * @brief Prepare the model.
   *
   */
  virtual void Prepare() {}

  /**
   * @brief Reset a vector from start to end with a value.
   *
   * @param v A vector to reset.
   * @param value The value you want to use for all elements in the
   * vector. The default is 0.0.
   */
  virtual void ResetVector(fims::Vector<Type> &v, Type value = 0.0) {
    std::fill(v.begin(), v.end(), value);
  }

  /**
   * @brief Evaluate the model.
   *
   */
  virtual void Evaluate() {}

  /**
   * @brief Report the model results via TMB.
   *
   */
  virtual void Report() {}

  /**
   * @brief Get the Id object.
   *
   * @return uint32_t
   */
  uint32_t GetId() { return this->id; }
};

template <typename Type>
uint32_t FisheryModelBase<Type>::id_g = 0;

}  // namespace fims_popdy
#endif

/**
 * @file fleet.hpp
 * @brief Declare the fleet functor class which is the base class for all fleet
 * functors.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_POPULATION_DYNAMICS_FLEET_HPP
#define FIMS_POPULATION_DYNAMICS_FLEET_HPP

#include "../../common/data_object.hpp"
#include "../../common/fims_vector.hpp"
#include "../../common/model_object.hpp"
#include "../../distributions/distributions.hpp"
#include "../selectivity/selectivity.hpp"

namespace fims_popdy {

/** @brief Base class for all fleets.
 *
 * @tparam Type The type of the fleet object.
 */
template <class Type>
struct Fleet : public fims_model_object::FIMSObject<Type> {
  static uint32_t id_g; /*!< reference id for fleet object*/
  size_t n_years;       /*!< the number of years in the model*/
  size_t n_ages;        /*!< the number of ages in the model*/
  size_t n_lengths;     /*!< the number of lengths in the model*/

  // selectivity
  int fleet_selectivity_id_m = -999; /*!< id of selectivity component*/
  std::shared_ptr<SelectivityBase<Type>>
      selectivity; /*!< selectivity component*/

  // landings data
  int fleet_observed_landings_data_id_m = -999; /*!< id of landings data */
  std::shared_ptr<fims_data_object::DataObject<Type>>
      observed_landings_data; /*!< observed landings data*/

  std::string observed_landings_units; /*!< is this fleet landings in weight*/

  // index data
  int fleet_observed_index_data_id_m = -999; /*!< id of index data */
  std::shared_ptr<fims_data_object::DataObject<Type>>
      observed_index_data; /*!< observed index data*/

  std::string observed_index_units; /*!< is this fleet index in weight*/

  // age comp data
  int fleet_observed_agecomp_data_id_m = -999; /*!< id of age comp data */
  std::shared_ptr<fims_data_object::DataObject<Type>>
      observed_agecomp_data; /*!< observed agecomp data*/

  // length comp data
  int fleet_observed_lengthcomp_data_id_m = -999; /*!< id of length comp data */
  std::shared_ptr<fims_data_object::DataObject<Type>>
      observed_lengthcomp_data; /*!< observed lengthcomp data*/

  // Mortality and catchability
  fims::Vector<Type>
      log_Fmort; /*!< estimated parameter: log Fishing mortality*/
  fims::Vector<Type>
      log_q; /*!< estimated parameter: catchability of the fleet */

  fims::Vector<Type> Fmort; /*!< transformed parameter: Fishing mortality*/
  fims::Vector<Type>
      q; /*!< transformed parameter: the catchability of the fleet */

  fims::Vector<Type> age_to_length_conversion; /*!<derived quantity age to
                                                length conversion matrix*/

  /**
   * @brief Constructor.
   */
  Fleet() { this->id = Fleet::id_g++; }

  /**
   * @brief Destructor.
   */
  virtual ~Fleet() {}

  /**
   * @brief Prepare to run the fleet module. Called at each model
   * iteration, and used to exponentiate the natural log of q and Fmort
   * parameters prior to evaluation.
   *
   */
  void Prepare() {
    // for(size_t fleet_ = 0; fleet_ <= this->n_fleets; fleet_++) {
    // this -> Fmort[fleet_] = fims_math::exp(this -> log_Fmort[fleet_]);

    for (size_t i = 0; i < this->log_q.size(); i++) {
      this->q[i] = fims_math::exp(this->log_q[i]);
    }

    for (size_t year = 0; year < this->n_years; year++) {
      this->Fmort[year] = fims_math::exp(this->log_Fmort[year]);
    }
  }
};

// default id of the singleton fleet class
template <class Type>
uint32_t Fleet<Type>::id_g = 0;

}  // end namespace fims_popdy

#endif /* FIMS_POPULATION_DYNAMICS_FLEET_HPP */

/**
 * @file ewaa.hpp
 * @brief Defines the EWAAGrowth class, which inherits from the GrowthBase
 * class.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef POPULATION_DYNAMICS_GROWTH_EWAA_HPP
#define POPULATION_DYNAMICS_GROWTH_EWAA_HPP

// #include "../../../interface/interface.hpp"
#include <map>

#include "growth_base.hpp"

namespace fims_popdy {

/**
 *  @brief EWAAGrowth class that returns the EWAA function value.
 */
template <typename Type>
struct EWAAGrowth : public GrowthBase<Type> {
  // add submodule class members here
  // these include parameters of the submodule
  // a map looks up values based on a reference key
  // in this case, our key is age (first double), and
  //  the value is the weight at that age (second double)
  std::map<int, std::map<double, double>> ewaa; /**<map of doubles for EWAA values by age,
          where age starts at zero > */
  typedef typename std::map<double, double>::iterator
      weight_iterator; /**< Iterator for ewaa map object > */

  EWAAGrowth() : GrowthBase<Type>() {}

  virtual ~EWAAGrowth() {}

  /**
   * @brief Returns the weight at age a (in kg) from the input vector.
   *
   * @param year year
   * @param a  age of the fish, the age vector must start at zero
   */
  virtual const Type evaluate(int year, const double& a) {
    return this->ewaa[year][a];
  }
};
}  // namespace fims_popdy
#endif /* POPULATION_DYNAMICS_GROWTH_EWAA_HPP */

/**
 * @file growth_base.hpp
 * @brief Declares the GrowthBase class which is the base class for all growth
 * functors.
 * @details Defines guards for growth module outline to define the
 * module_name_base hpp file if not already defined.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef POPULATION_DYNAMICS_GROWTH_BASE_HPP
#define POPULATION_DYNAMICS_GROWTH_BASE_HPP

#include "../../../common/model_object.hpp"

namespace fims_popdy {

/**
 * @brief Base class for all growth functors.
 *
 * @tparam Type The type of the growth functor.
 */
template <typename Type>
struct GrowthBase : public fims_model_object::FIMSObject<Type> {
  // id_g is the ID of the instance of the  growthBase class.
  // this is like a memory tracker.
  // Assigning each one its own ID is a way to keep track of
  // all the instances of the  growthBase class.
  static uint32_t id_g; /**< reference id for growth object*/

  /**
   * @brief Constructor.
   */
  GrowthBase() { this->id = GrowthBase::id_g++; }

  virtual ~GrowthBase() {}

  /**
   * @brief Calculates the  growth at the independent variable value.
   * @param year The year at which to return weight of the fish (in kg).
   * @param a The age at which to return weight of the fish (in kg).
   */
  virtual const Type evaluate(int year, const double& a) = 0;
};

template <typename Type>
uint32_t GrowthBase<Type>::id_g = 0;

}  // namespace fims_popdy

#endif /* POPULATION_DYNAMICS_GROWTH_BASE_HPP */

/**
 * @file logistic.hpp
 * @brief Defines the LogisticMaturity class, which inherits from the
 * MaturityBase class.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 *
 */
#ifndef POPULATION_DYNAMICS_MATURITY_LOGISTIC_HPP
#define POPULATION_DYNAMICS_MATURITY_LOGISTIC_HPP

#include "../../../common/fims_math.hpp"
#include "../../../common/fims_vector.hpp"
#include "maturity_base.hpp"

namespace fims_popdy {

/**
 *  @brief LogisticMaturity class that returns the logistic function value
 * from fims_math.
 */
template <typename Type>
struct LogisticMaturity : public MaturityBase<Type> {
  fims::Vector<Type>
      inflection_point; /**< 50 percent quantile of the value of the quantity of
interest (x); e.g. age at which 50 percent of the fish are mature */
  fims::Vector<Type> slope; /**<scalar multiplier of difference between quantity
            of interest value (x) and inflection_point */

  LogisticMaturity() : MaturityBase<Type>() {}

  /**
   * @brief Method of the logistic maturity class that implements the
   * logistic function from FIMS math.
   *
   * \f[ \frac{1.0}{ 1.0 + exp(-1.0 * slope (x - inflection_point))} \f]
   *
   * @param x  The independent variable in the logistic function (e.g., age or
   * size at maturity).
   */

  virtual const Type evaluate(const Type& x) {
    return fims_math::logistic<Type>(inflection_point[0], slope[0], x);
  }

  /**
   * @brief Method of the logistic maturity class that implements the
   * logistic function from FIMS math.
   *
   * \f[ \frac{1.0}{ 1.0 + exp(-1.0 * slope_t (x - {inflection\_point}_t))} \f]
   *
   * @param x  The independent variable in the logistic function (e.g., age or
   * size in selectivity).
   * @param pos Position index, e.g., which year.
   */
  virtual const Type evaluate(const Type& x, size_t pos) {
    return fims_math::logistic<Type>(inflection_point.get_force_scalar(pos),
                                     slope.get_force_scalar(pos), x);
  }
};

}  // namespace fims_popdy

#endif /* POPULATION_DYNAMICS_MATURITY_LOGISTIC_HPP */

/**
 * @file maturity_base.hpp
 * @brief Declares the MaturityBase class which is the base class for all
 * maturity functors.
 * @details Defines guards for maturity module outline to define the maturity
 * hpp file if not already defined.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef POPULATION_DYNAMICS_MATURITY_BASE_HPP
#define POPULATION_DYNAMICS_MATURITY_BASE_HPP

#include "../../../common/model_object.hpp"

namespace fims_popdy {

/** @brief Base class for all maturity functors.
 *
 * @tparam Type The type of the maturity functor.
 */

template <typename Type>
struct MaturityBase : public fims_model_object::FIMSObject<Type> {
  // id_g is the ID of the instance of the MaturityBase class.
  // this is like a memory tracker.
  // Assigning each one its own ID is a way to keep track of
  // all the instances of the MaturityBase class.
  static uint32_t id_g; /**< The ID of the instance of the MaturityBase class */

  /** @brief Constructor.
   */
  MaturityBase() {
    // increment id of the singleton maturity class
    this->id = MaturityBase::id_g++;
  }

  /**
   * @brief Calculates the maturity.
   * @param x The independent variable in the maturity function (e.g., logistic
   * maturity at age or size).
   */
  virtual const Type evaluate(const Type& x) = 0;
  /**
   * @brief Calculates the selectivity.
   * @param x The independent variable in the logistic function (e.g., age or
   * size in selectivity).
   * @param pos Position index, e.g., which year.
   */
  virtual const Type evaluate(const Type& x, size_t pos) = 0;
};

// default id of the singleton maturity class
template <typename Type>
uint32_t MaturityBase<Type>::id_g = 0;

}  // namespace fims_popdy

#endif /* POPULATION_DYNAMICS_MATURITY_BASE_HPP */

/**
 * @file population.hpp
 * @brief Defines the Population class and its fields and methods.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_POPULATION_DYNAMICS_POPULATION_HPP
#define FIMS_POPULATION_DYNAMICS_POPULATION_HPP

#include "../../common/model_object.hpp"
#include "../fleet/fleet.hpp"
#include "../growth/growth.hpp"
#include "../recruitment/recruitment.hpp"
#include "../../interface/interface.hpp"
#include "../maturity/maturity.hpp"

namespace fims_popdy {

/**
 * @brief Population class. Contains subpopulations
 * that are divided into generic partitions (e.g., sex, area).
 */
template <typename Type>
struct Population : public fims_model_object::FIMSObject<Type> {
  static uint32_t id_g; /*!< reference id for population object*/
  size_t n_years;       /*!< total number of years in the fishery*/
  size_t n_ages;        /*!< total number of ages in the population*/
  size_t n_fleets;      /*!< total number of fleets in the fishery*/

  // parameters are estimated; after initialize in create_model, push_back to
  // parameter list - in information.hpp (same for initial F in fleet)
  fims::Vector<Type>
      log_init_naa; /*!< estimated parameter: natural log of numbers at age*/
  fims::Vector<Type>
      log_M; /*!< estimated parameter: natural log of Natural Mortality*/
  fims::Vector<Type> proportion_female = fims::Vector<Type>(
      1, static_cast<Type>(0.5));            /*!< proportion female by age */
  fims::Vector<Type> log_f_multiplier;       /*!< estimated parameter: vector of
    annual fishing mortality multipliers to scale total mortality of all fleets*/
  fims::Vector<Type> spawning_biomass_ratio; /*!< estimated parameter: vector of
annual fishing mortality multipliers to scale total mortality of all fleets*/

  // Transformed values
  fims::Vector<Type> M; /*!< transformed parameter: natural mortality*/
  fims::Vector<Type> f_multiplier; /*!< transformed parameter: vector of
annual fishing mortality multipliers to scale total mortality of all fleets*/

  fims::Vector<double> ages;  /*!< vector of the ages for referencing*/
  fims::Vector<double> years; /*!< vector of years for referencing*/

  /// recruitment
  int recruitment_id = -999; /*!< id of recruitment model object*/
  std::shared_ptr<fims_popdy::RecruitmentBase<Type>>
      recruitment; /*!< shared pointer to recruitment module */

  // growth
  int growth_id = -999; /*!< id of growth model object*/
  std::shared_ptr<fims_popdy::GrowthBase<Type>>
      growth; /*!< shared pointer to growth module */

  // maturity
  int maturity_id = -999; /*!< id of maturity model object*/
  std::shared_ptr<fims_popdy::MaturityBase<Type>>
      maturity; /*!< shared pointer to maturity module */

  // fleet
  std::set<uint32_t> fleet_ids; /*!< id of fleet model object*/
  std::vector<std::shared_ptr<fims_popdy::Fleet<Type>>>
      fleets; /*!< shared pointer to fleet module */

  /**
   * @brief Constructor.
   */
  Population() { this->id = Population::id_g++; }
};
template <class Type>
uint32_t Population<Type>::id_g = 0;

}  // namespace fims_popdy

#endif /* FIMS_POPULATION_DYNAMICS_POPULATION_HPP */

/**
 * @file log_devs.hpp
 * @brief Incorporates error using the log recruitment deviations approach.
 * @details This function inherits from recruitment base.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_POPULATION_DYNAMICS_RECRUITMENT_LOG_DEVS_HPP
#define FIMS_POPULATION_DYNAMICS_RECRUITMENT_LOG_DEVS_HPP

#include "recruitment_base.hpp"
#include "../../../common/fims_vector.hpp"

namespace fims_popdy {

/** @brief Log Devs class that returns the log of the input added to the log of
 * the recruitment deviations.
 */
template <typename Type>
struct LogDevs : public RecruitmentBase<Type> {
  LogDevs() : RecruitmentBase<Type>() {}

  virtual ~LogDevs() {}

  /** @brief Log of the recruitment deviations approach to adding error to
   * expected recruitment.
   *
   * The Log Recruitment Deviation implementation:
   * \f$ \text{log expected recruitment} + log_devs \f$
   *
   * @param pos Position index, e.g., which year.
   */
  virtual const Type evaluate_process(size_t pos) {
    return this->recruitment->log_expected_recruitment[pos] +
           this->recruitment->log_recruit_devs[pos];
  }

  /** Empty return of base class function */
  virtual const Type evaluate_mean(const Type& spawners, const Type& phi_0) {
    return 0;
  }
};

}  // namespace fims_popdy

#endif /* FIMS_POPULATION_DYNAMICS_RECRUITMENT_LOG_DEVS_HPP */

/**
 * @file log_r.hpp
 * @brief Incorporates error using the log recruitment approach.
 * @details This function inherits from recruitment base.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_POPULATION_DYNAMICS_RECRUITMENT_LOG_R_HPP
#define FIMS_POPULATION_DYNAMICS_RECRUITMENT_LOG_R_HPP

#include "recruitment_base.hpp"
#include "../../../common/fims_vector.hpp"

namespace fims_popdy {

/** @brief Log Devs class that returns the log of the input added to the log of
 * the recruitment deviations.
 */
template <typename Type>
struct LogR : public RecruitmentBase<Type> {
  LogR() : RecruitmentBase<Type>() {}

  virtual ~LogR() {}

  /** @brief Log of recruitment approach to adding error to expected
   * recruitment.
   *
   * The Log Recruitment implementation:
   * \f$ \text{log expected recruitment} \f$
   *
   * @param pos Position index, e.g., which year.
   */
  virtual const Type evaluate_process(size_t pos) {
    return this->recruitment->log_r[pos];
  }

  /** Empty return of base class function */
  virtual const Type evaluate_mean(const Type& spawners, const Type& phi_0) {
    return 0;
  }
};

}  // namespace fims_popdy

#endif /* FIMS_POPULATION_DYNAMICS_RECRUITMENT_LOG_R_HPP */

/**
 * @file recruitment_base.hpp
 * @brief Serves as the parent class where recruitment functions are called.
 * @details Defines guards for recruitment base outline to define the
 * recruitment hpp file if not already defined.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_POPULATION_DYNAMICS_RECRUITMENT_BASE_HPP
#define FIMS_POPULATION_DYNAMICS_RECRUITMENT_BASE_HPP

#include <cmath>  // for using std::pow and M_PI

#include "../../../common/fims_math.hpp"  // for using fims_math::log()
#include "../../../common/fims_vector.hpp"
#include "../../../common/model_object.hpp"
#include "../../../distributions/distributions.hpp"

namespace fims_popdy {

/** @brief Base class for all recruitment functors.
 *
 * @tparam Type The type of the recruitment functor.
 *
 */
template <class Type>
struct RecruitmentBase : public fims_model_object::FIMSObject<Type> {
  static uint32_t id_g; /**< reference id for recruitment object*/

  fims::Vector<Type> log_recruit_devs; /*!< A vector of the natural log of
                                          recruitment deviations */
  bool constrain_deviations = false;   /*!< A flag to indicate if recruitment
                                   deviations are summing to zero or not */

  fims::Vector<Type> log_rzero; /**< Natural log of unexploited recruitment.*/
  fims::Vector<Type>
      log_r; /**< Natural log of recruitment used for random effects */
  fims::Vector<Type>
      log_expected_recruitment; /**< Expectation of the recruitment process */

  bool estimate_log_recruit_devs = true; /*!< A flag to indicate if recruitment
                                  deviations are estimated or not */

  int process_id = -999; /*!< id of recruitment process model object*/
  std::shared_ptr<fims_popdy::RecruitmentBase<Type>>
      process; /*!< shared pointer to recruitment processmodule */
  std::shared_ptr<fims_popdy::RecruitmentBase<Type>>
      recruitment; /*!< shared pointer to recruitment module */

  /** @brief Constructor.
   */
  RecruitmentBase() { this->id = RecruitmentBase::id_g++; }

  virtual ~RecruitmentBase() {}

  /**
   * @brief Prepares the recruitment deviations vector.
   *
   */
  void Prepare() {
    // this->PrepareConstrainedDeviations();
    std::fill(log_expected_recruitment.begin(), log_expected_recruitment.end(),
              0.0);
  }

  /** @brief Calculates the expected recruitment for a given spawning input.
   *
   * @param spawners A measure for spawning output.
   * @param ssbzero A measure for spawning output in unfished population.
   *
   */
  virtual const Type evaluate_mean(
      const Type &spawners,
      const Type &ssbzero) = 0;  // need to add input parameter values

  /** @brief Handle error in recruitment
   *
   * @param pos Position index, e.g., which year.
   */
  virtual const Type evaluate_process(size_t pos) = 0;

  /** @brief Prepare constrained recruitment deviations.
   *  Based on ADMB sum-to-zero constraint implementation. We still
   *  need to add an additional penalty to the PrepareConstrainedDeviations
   *  method. More discussion can be found here:
   *  https://groups.google.com/a/ADMB-project.org/g/users/c/63YJmYGEPuE
   */
  void PrepareConstrainedDeviations() {
    if (!this->constrain_deviations) {
      return;
    }

    Type sum = static_cast<Type>(0.0);

    for (size_t i = 0; i < this->log_recruit_devs.size(); i++) {
      sum += this->log_recruit_devs[i];
    }

    for (size_t i = 0; i < this->log_recruit_devs.size(); i++) {
      this->log_recruit_devs[i] -= sum / (this->log_recruit_devs.size());
    }
  }
};

template <class Type>
uint32_t RecruitmentBase<Type>::id_g = 0;
}  // namespace fims_popdy

#endif /* FIMS_POPULATION_DYNAMICS_RECRUITMENT_BASE_HPP */

/**
 * @file sr_beverton_holt.hpp
 * @brief Calls the Beverton--Holt stock--recruitment function from fims_math
 * and does the calculation.
 * @details This function inherits from recruitment base.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef FIMS_POPULATION_DYNAMICS_RECRUITMENT_SR_BEVERTON_HOLT_HPP
#define FIMS_POPULATION_DYNAMICS_RECRUITMENT_SR_BEVERTON_HOLT_HPP

#include "recruitment_base.hpp"
#include "../../../common/fims_vector.hpp"

namespace fims_popdy {

/** @brief BevertonHolt class that returns the Beverton--Holt
 * stock--recruitment from fims_math.
 *
 * See the @ref glossary for definitions of mathematical symbols used below.
 *
 * @param logit_steep Recruitment relative to unfished recruitment at 20
 * percent of unfished spawning biomass. Steepness is subject to a logit
 * transformation to keep it between 0.2 and 1.0.
 */
template <typename Type>
struct SRBevertonHolt : public RecruitmentBase<Type> {
  // Here we define the members that will be used in the Beverton--Holt
  // stock--recruitment function. These members are needed by the Beverton--Holt
  // stock--recruitment function but will not be common to all recruitment
  // functions like spawners is below.
  fims::Vector<Type> logit_steep; /**< Transformed value of recruitment
                                  relative to unfished
                                  recruitment at 20 percent of unfished
                                  spawning biomass.*/

  SRBevertonHolt() : RecruitmentBase<Type>() {}

  virtual ~SRBevertonHolt() {}

  /** @brief Beverton--Holt implementation of the stock--recruitment function.
   *
   * The Beverton--Holt stock--recruitment implementation:
   * \f$ \frac{0.8 R_{0} h S_{t-1}}{0.2 R_{0} \phi_{0} (1 - h) + S_{t-1} (h -
   * 0.2)} \f$
   *
   * @param spawners A measure of spawning output.
   * @param phi_0 Number of spawners per recruit of an unfished population
   */
  virtual const Type evaluate_mean(const Type& spawners, const Type& phi_0) {
    Type recruits;
    Type steep;
    Type steep_lo = static_cast<Type>(0.2);
    Type steep_hi = static_cast<Type>(1.0);
    Type rzero;

    // Transform input parameters
    steep = fims_math::inv_logit(steep_lo, steep_hi, this->logit_steep[0]);
    rzero = fims_math::exp(this->log_rzero[0]);

    recruits = (static_cast<Type>(0.8) * rzero * steep * spawners) /
               (static_cast<Type>(0.2) * phi_0 * rzero *
                    (static_cast<Type>(1.0) - steep) +
                spawners * (steep - static_cast<Type>(0.2)));

    return recruits;
  }

  /** Empty return of base class function
   * @param pos position index
   */
  virtual const Type evaluate_process(size_t pos) { return 0; }
};

}  // namespace fims_popdy

#endif /* FIMS_POPULATION_DYNAMICS_RECRUITMENT_SR_BEVERTON_HOLT_HPP */

/**
 * @file double_logistic.hpp
 * @brief Declares the DoubleLogisticSelectivity class which implements the
 * logistic function from fims_math in the selectivity module.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef POPULATION_DYNAMICS_SELECTIVITY_DOUBLE_LOGISTIC_HPP
#define POPULATION_DYNAMICS_SELECTIVITY_DOUBLE_LOGISTIC_HPP

// #include "../../../interface/interface.hpp"
#include "../../../common/fims_math.hpp"
#include "../../../common/fims_vector.hpp"
#include "selectivity_base.hpp"

namespace fims_popdy {

/**
 * @brief DoubleLogisticSelectivity class that returns the double logistic
 * function value from fims_math.
 */
template <typename Type>
struct DoubleLogisticSelectivity : public SelectivityBase<Type> {
  fims::Vector<Type> inflection_point_asc; /**< 50% quantile of the value of the
             quantity of interest (x)  on the ascending limb of the double
             logistic curve; e.g. age at  which 50% of the fish are selected */
  fims::Vector<Type> slope_asc; /**<scalar multiplier of difference between
            quantity of interest   value (x) and inflection_point on the
            ascending limb of the double   logistic   curve*/
  fims::Vector<Type> inflection_point_desc; /**< 50% quantile of the value of
             the quantity of interest (x) on the descending limb of the double
             logistic curve; e.g. age at which 50% of the fish are selected */
  fims::Vector<Type> slope_desc; /**<scalar multiplier of difference between
            quantity of interest  value (x) and inflection_point on the
            descending limb of the double  logistic  curve */

  DoubleLogisticSelectivity() : SelectivityBase<Type>() {}

  virtual ~DoubleLogisticSelectivity() {}

  /**
   * @brief Method of the double logistic selectivity class that implements the
   * double logistic function from FIMS math.
   *
   * \f$ \frac{1.0}{ 1.0 + exp(-1.0 * slope\_asc (x - inflection_point\_asc))}
   * \left(1.0-\frac{1.0}{ 1.0 + exp(-1.0 * slope\_desc (x -
   * inflection_point\_desc))} \right)\f$
   *
   * @param x  The independent variable in the double logistic function (e.g.,
   * age or size in selectivity).
   */
  virtual const Type evaluate(const Type& x) {
    return fims_math::double_logistic<Type>(
        inflection_point_asc[0], slope_asc[0], inflection_point_desc[0],
        slope_desc[0], x);
  }

  /**
   * @brief Method of the double logistic selectivity class that implements the
   * double logistic function from FIMS math.
   *
   * \f$ \frac{1.0}{ 1.0 + exp(-1.0 * slope\_asc_t (x -
   * inflection_point\_asc_t))} \left(1.0-\frac{1.0}{ 1.0 + exp(-1.0 *
   * slope\_desc_t (x - inflection_point\_desc_t))} \right)\f$
   *
   * @param x  The independent variable in the double logistic function (e.g.,
   * age or size in selectivity).
   * @param pos Position index, e.g., which year. If the index is out of bounds
   * then it returns the first element, which would be the case when you do not
   * have time-varying selectivity.
   */
  virtual const Type evaluate(const Type& x, size_t pos) {
    return fims_math::double_logistic<Type>(
        inflection_point_asc.get_force_scalar(pos),
        slope_asc.get_force_scalar(pos),
        inflection_point_desc.get_force_scalar(pos),
        slope_desc.get_force_scalar(pos), x);
  }
};

}  // namespace fims_popdy

#endif /* POPULATION_DYNAMICS_SELECTIVITY_DOUBLE_LOGISTIC_HPP */

/**
 * @file logistic.hpp
 * @brief Declares the LogisticSelectivity class which implements the logistic
 * function from fims_math in the selectivity module.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef POPULATION_DYNAMICS_SELECTIVITY_LOGISTIC_HPP
#define POPULATION_DYNAMICS_SELECTIVITY_LOGISTIC_HPP

// #include "../../../interface/interface.hpp"
#include "../../../common/fims_math.hpp"
#include "../../../common/fims_vector.hpp"
#include "selectivity_base.hpp"

namespace fims_popdy {

/**
 *  @brief LogisticSelectivity class that returns the logistic function value
 * from fims_math.
 *
 * The logistic selectivity function can produce either an ascending or
 * descending curve based on the sign of the slope parameter. A positive slope
 * creates an ascending logistic curve (selectivity increases from 0 to 1 with
 * increasing x), while a negative slope creates a descending logistic curve
 * (selectivity decreases from 1 to 0 with increasing x).
 */
template <typename Type>
struct LogisticSelectivity : public SelectivityBase<Type> {
  fims::Vector<Type>
      inflection_point;     /**< 50% quantile of the value of the quantity of
  interest (x); e.g. age at which 50% of the fish are selected */
  fims::Vector<Type> slope; /**<scalar multiplier of difference between quantity
            of interest value (x) and inflection_point. Positive values create
            an ascending curve (0 to 1), negative values create a descending
            curve (1 to 0). */

  LogisticSelectivity() : SelectivityBase<Type>() {}

  virtual ~LogisticSelectivity() {}

  /**
   * @brief Method of the logistic selectivity class that implements the
   * logistic function from FIMS math.
   *
   * \f[ \frac{1.0}{ 1.0 + exp(-1.0 * slope (x - inflection\_point))} \f]
   *
   * The selectivity curve can be either ascending or descending depending on
   * the sign of the slope parameter:
   * - Positive slope: ascending curve (selectivity increases from 0 to 1)
   * - Negative slope: descending curve (selectivity decreases from 1 to 0)
   *
   * @param x  The independent variable in the logistic function (e.g., age or
   * size in selectivity).
   */
  virtual const Type evaluate(const Type &x) {
    return fims_math::logistic<Type>(inflection_point[0], slope[0], x);
  }

  /**
   * @copydoc LogisticSelectivity::evaluate(const Type &x)
   * @param pos Position index, e.g., which year. If the index is out of bounds
   * then it returns the first element, which would be the case when you do not
   * have time-varying selectivity.
   */
  virtual const Type evaluate(const Type &x, size_t pos) {
    return fims_math::logistic<Type>(inflection_point.get_force_scalar(pos),
                                     slope.get_force_scalar(pos), x);
  }
};

}  // namespace fims_popdy

#endif /* POPULATION_DYNAMICS_SELECTIVITY_LOGISTIC_HPP */

/**
 * @file selectivity_base.hpp
 * @brief Declares the SelectivityBase class which is the base class for all
 * selectivity functors.
 * @details Defines guards for selectivity module outline to define the
 * selectivity hpp file if not already defined.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef POPULATION_DYNAMICS_SELECTIVITY_BASE_HPP
#define POPULATION_DYNAMICS_SELECTIVITY_BASE_HPP

#include "../../../common/model_object.hpp"

namespace fims_popdy {

/** @brief Base class for all selectivity functors.
 *
 * @tparam Type The type of the selectivity functor.
 */

template <typename Type>
struct SelectivityBase : public fims_model_object::FIMSObject<Type> {
  // id_g is the ID of the instance of the SelectivityBase class.
  // this is like a memory tracker.
  // Assigning each one its own ID is a way to keep track of
  // all the instances of the SelectivityBase class.
  static uint32_t
      id_g; /**< The ID of the instance of the SelectivityBase class */

  /** @brief Constructor.
   */
  SelectivityBase() {
    // increment id of the singleton selectivity class
    this->id = SelectivityBase::id_g++;
  }

  virtual ~SelectivityBase() {}

  /**
   * @brief Calculates the selectivity.
   * @param x The independent variable in the logistic function (e.g., age or
   * size in selectivity).
   */
  virtual const Type evaluate(const Type& x) = 0;

  /**
   * @brief Calculates the selectivity.
   * @param x The independent variable in the logistic function (e.g., age or
   * size in selectivity).
   * @param pos Position index, e.g., which year.
   */
  virtual const Type evaluate(const Type& x, size_t pos) = 0;
};

// default id of the singleton selectivity class
template <typename Type>
uint32_t SelectivityBase<Type>::id_g = 0;

}  // namespace fims_popdy

#endif /* POPULATION_DYNAMICS_SELECTIVITY_BASE_HPP */

#ifndef FIMS_JSON_HPP
#define FIMS_JSON_HPP

/**
 * @file fims_json.hpp
 * @brief A simple JSON parsing and generation library.
 * @details This library provides classes and functions for parsing JSON
 * strings and generating JSON data structures.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#include <cctype>
#include <iostream>
#include <fstream>
#include <map>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>

namespace fims {
class JsonValue;

/**
 * Alias for a JSON object, mapping strings to JSON values.
 */
using JsonObject = std::map<std::string, JsonValue>;

/**
 * Alias for a JSON array, containing a sequence of JSON values.
 */
using JsonArray = std::vector<JsonValue>;

/**
 * Represents different types of JSON values.
 */
enum JsonValueType {
  Null = 0, /**< Null JSON value. */
  Number,   /**< Numeric JSON value. */
  String,   /**< String JSON value. */
  Bool,     /**< Boolean JSON value. */
  Object,   /**< JSON object. */
  JArray    /**< JSON array. */
};

/**
 * Represents a JSON value.
 */
class JsonValue {
 public:
  /** Default constructor, initializes to Null value. */
  JsonValue() : type(JsonValueType::Null) {}

  /** Constructor for numeric JSON value (i.e., integer). */
  JsonValue(int num) : type(JsonValueType::Number), number(num) {}

  /** Constructor for numeric JSON value (i.e., double). */
  JsonValue(double num) : type(JsonValueType::Number), number(num) {}

  /** Constructor for string JSON value. */
  JsonValue(const std::string& str) : type(JsonValueType::String), str(str) {}

  /** Constructor for boolean JSON value. */
  JsonValue(bool b) : type(JsonValueType::Bool), boolean(b) {}

  /** Constructor for JSON object value. */
  JsonValue(const JsonObject& obj) : type(JsonValueType::Object), object(obj) {}

  /** Constructor for JSON array value. */
  JsonValue(const JsonArray& arr) : type(JsonValueType::JArray), array(arr) {}

  /** Get the type of the JSON value. */
  JsonValueType GetType() const { return type; }

  /** Get the numeric value as an integer. */
  int GetInt() const { return static_cast<int>(number); }

  /** Get the numeric value as a double. */
  double GetDouble() const { return number; }

  /** Get the string value. */
  const std::string& GetString() const { return str; }

  /** Get the boolean value. */
  bool GetBool() const { return boolean; }

  /** Get the JSON object. */
  JsonObject& GetObject() { return object; }

  /** Get the JSON array. */
  JsonArray& GetArray() { return array; }

 private:
  JsonValueType type; /**< Type of the JSON value. */
  double number;      /**< Numeric value. */
  std::string str;    /**< String value. */
  bool boolean;       /**< Boolean value. */
  JsonObject object;  /**< JSON object. */
  JsonArray array;    /**< JSON array. */
};

/**
 * Parses JSON strings and generates JSON values.
 */
class JsonParser {
 public:
  /** Parse a JSON string and return the corresponding JSON value. */
  JsonValue Parse(const std::string& json);
  /** Write a JSON value to a file. */
  void WriteToFile(const std::string& filename, JsonValue jsonValue);
  /** Display a JSON value to the standard output. */
  void Show(JsonValue jsonValue);

  /** Remove whitespace in JSON. */
  static std::string removeWhitespace(const std::string& input) {
    std::string result = input;
    result.erase(std::remove_if(result.begin(), result.end(), ::isspace),
                 result.end());
    return result;
  }

  /**
   * @brief Formats a JSON string.
   * @param json
   * @return
   */
  static std::string PrettyFormatJSON(const std::string& json) {
    std::string result;
    std::string input = JsonParser::removeWhitespace(json);
    int indentLevel = 0;
    bool inQuotes = false;

    for (size_t i = 0; i < input.size(); ++i) {
      char current = input[i];

      switch (current) {
        case '{':
        case '[':
          result += current;
          if (!inQuotes) {
            result += '\n';
            indentLevel++;
            result += std::string(indentLevel * 4, ' ');
          }
          break;

        case '}':
        case ']':
          if (!inQuotes) {
            result += '\n';
            indentLevel--;
            result += std::string(indentLevel * 4, ' ');
          }
          result += current;
          break;

        case ',':
          result += current;
          if (!inQuotes) {
            result += '\n';
            result += std::string(indentLevel * 4, ' ');
          }
          break;

        case ':':
          result += current;
          if (!inQuotes) result += " ";
          break;

        case '"':
          result += current;
          // Toggle inQuotes when we encounter a double-quote
          if (i == 0 || input[i - 1] != '\\') {
            inQuotes = !inQuotes;
          }
          break;

        default:
          result += current;
          break;
      }
    }
    return result;
  }

 private:
  /** Skip whitespace characters in the input string. */
  void SkipWhitespace();
  /** Parse a JSON value. */
  JsonValue ParseValue();
  /** Parse a numeric JSON value. */
  JsonValue ParseNumber();
  /** Parse a string JSON value. */
  JsonValue ParseString();
  /** Parse a boolean JSON value. */
  JsonValue ParseBool();
  /** Parse a null JSON value. */
  JsonValue ParseNull();
  /** Parse a JSON object. */
  JsonValue ParseObject();
  /** Parse a JSON array. */
  JsonValue ParseArray();
  /** Write a JSON value to an output file stream. */
  void WriteJsonValue(std::ofstream& outputFile, JsonValue jsonValue);
  /** Display a JSON value to an output stream. */
  void PrintJsonValue(std::ostream& outputFile, JsonValue jsonValue);
  /** Indentation helper for printing JSON values in an output file stream. */
  void Indent(std::ostream& outputFile, int level);
  /** Indentation helper for printing JSON values in an output stream. */
  void Indent(std::ofstream& outputFile, int level);

  std::string data; /**< Input JSON data. */
  size_t position;  /**< Current position in the data. */
};

/**
 * Parse a JSON string and return the corresponding JSON value.
 * @param json The JSON string to parse.
 * @return The parsed JSON value.
 */
JsonValue JsonParser::Parse(const std::string& json) {
  data = json;
  position = 0;
  return ParseValue();
}

/**
 * @brief Skip the white space.
 *
 */
void JsonParser::SkipWhitespace() {
  while (position < data.size() && std::isspace(data[position])) {
    position++;
  }
}

/**
 * Parse a JSON value.
 *  @return The parsed JSON value.
 */
JsonValue JsonParser::ParseValue() {
  /** Skip whitespace characters in the input string. */
  SkipWhitespace();
  if (position >= data.size()) {
    return JsonValue();
  }

  char current = data[position];
  if (current == '{') {
    return ParseObject();
  } else if (current == '[') {
    return ParseArray();
  } else if (current == '"') {
    return ParseString();
  } else if (current == 't' || current == 'f') {
    return ParseBool();
  } else if (current == 'n') {
    return ParseNull();
  } else if (std::isdigit(current) || current == '-') {
    return ParseNumber();
  } else {
    // Unknown token.
    position++;
    return JsonValue();
  }
}

/**
 * Parse a numeric JSON value.
 * @return The parsed JSON value.
 */
JsonValue JsonParser::ParseNumber() {
  size_t end_pos = position;
  bool is_float = false;
  while (end_pos < data.size() &&
         (std::isdigit(data[end_pos]) || data[end_pos] == '.' ||
          data[end_pos] == '-' || data[end_pos] == 'e' ||
          data[end_pos] == 'E')) {
    if (data[end_pos] == '.' || data[end_pos] == 'e' || data[end_pos] == 'E') {
      is_float = true;
    }
    end_pos++;
  }

  std::string num_str = data.substr(position, end_pos - position);
  position = end_pos;

  if (is_float) {
    double num = 0.0;
    std::istringstream(num_str) >> num;
    return JsonValue(num);
  } else {
    int num = 0;
    std::istringstream(num_str) >> num;
    return JsonValue(num);
  }
}

/**
 * Parse a string JSON value.
 * @return The parsed JSON value.
 */
JsonValue JsonParser::ParseString() {
  position++;  // Skip the initial '"'
  size_t end_pos = data.find('"', position);
  if (end_pos == std::string::npos) {
    std::string str = data.substr(position);
    position = data.size();
    return JsonValue(str);
  }
  std::string str = data.substr(position, end_pos - position);
  position = end_pos + 1;
  return JsonValue(str);
}

/**
 * Parse a boolean JSON value.
 * @return The parsed JSON value.
 */
JsonValue JsonParser::ParseBool() {
  if (data.compare(position, 4, "true") == 0) {
    position += 4;
    return JsonValue(true);
  } else if (data.compare(position, 5, "false") == 0) {
    position += 5;
    return JsonValue(false);
  } else {
    // Invalid boolean value
    return JsonValue();
  }
}

/**
 * Parse a null JSON value.
 * @return The parsed JSON value.
 */
JsonValue JsonParser::ParseNull() {
  if (data.compare(position, 4, "null") == 0) {
    position += 4;
    return JsonValue();
  } else {
    // Invalid null value
    return JsonValue();
  }
}

/**
 * Parse a JSON object.
 * @return The parsed JSON value representing the object.
 */
JsonValue JsonParser::ParseObject() {
  JsonObject obj;
  position++;  // Skip the initial '{'

  SkipWhitespace();
  if (position < data.size() && data[position] == '}') {
    position++;  // Skip empty object close brace
    return JsonValue(obj);
  }

  while (position < data.size() && data[position] != '}') {
    SkipWhitespace();
    if (position >= data.size() || data[position] != '"') {
      return JsonValue(obj);
    }
    std::string key = ParseString().GetString();

    SkipWhitespace();
    if (position >= data.size() || data[position] != ':') {
      return JsonValue(obj);
    }
    position++;  // Skip the ':'
    SkipWhitespace();
    JsonValue value = ParseValue();
    obj[key] = value;

    SkipWhitespace();
    if (position < data.size() && data[position] == ',') {
      position++;
    }
  }

  if (position < data.size() && data[position] == '}') {
    position++;  // Skip the trailing '}'
  }
  return JsonValue(obj);
}

/**
 * Parse a JSON array.
 * @return The parsed JSON value representing the array.
 */
JsonValue JsonParser::ParseArray() {
  JsonArray arr;
  position++;  // Skip the initial '['

  SkipWhitespace();
  if (position < data.size() && data[position] == ']') {
    position++;  // Skip empty array close bracket
    return JsonValue(arr);
  }

  while (position < data.size() && data[position] != ']') {
    SkipWhitespace();
    JsonValue value = ParseValue();
    arr.push_back(value);

    SkipWhitespace();
    if (position < data.size() && data[position] == ',') {
      position++;
    }
  }

  if (position < data.size() && data[position] == ']') {
    position++;  // Skip the trailing ']'
  }
  return JsonValue(arr);
}

/**
 *  Write a JSON value to an output file.
 * @param filename The name of the output file.
 * @param jsonValue The JSON value to write.
 */
void JsonParser::WriteToFile(const std::string& filename, JsonValue jsonValue) {
  std::ofstream outputFile(filename);
  if (!outputFile) {
    std::cerr << "Error: Unable to open file " << filename << " for writing."
              << std::endl;
    return;
  }

  /** Call a private helper function to write JSON values recursively */
  WriteJsonValue(outputFile, jsonValue);
}

/**
 * Write a JSON value to an output file.
 * Private helper function to write JSON values recursively
 * @param outputFile The output file stream.
 *  @param jsonValue The JSON value to write.
 */
void JsonParser::WriteJsonValue(std::ofstream& outputFile,
                                JsonValue jsonValue) {
  switch (jsonValue.GetType()) {
    case JsonValueType::Null:
      outputFile << "null";
      break;
    case JsonValueType::Number:
      outputFile << jsonValue.GetDouble();
      break;
    case JsonValueType::String:
      outputFile << "\"" << jsonValue.GetString() << "\"";
      break;
    case JsonValueType::Bool:
      outputFile << (jsonValue.GetBool() ? "true" : "false");
      break;
    case JsonValueType::Object: {
      JsonObject& obj = jsonValue.GetObject();
      outputFile << "{";
      bool first = true;
      for (const auto& pair : obj) {
        if (!first) {
          outputFile << ",";
        }
        first = false;
        outputFile << "\"" << pair.first << "\":";
        WriteJsonValue(outputFile, pair.second);
      }
      outputFile << "}";
    } break;
    case JsonValueType::JArray: {
      JsonArray& arr = jsonValue.GetArray();
      outputFile << "[";
      bool first = true;
      for (const auto& value : arr) {
        if (!first) {
          outputFile << ",";
        }
        first = false;
        WriteJsonValue(outputFile, value);
      }
      outputFile << "]";
    } break;
  }
}

/**
 * Display a JSON value to the standard output.
 * @param jsonValue The JSON value to display.
 */
void JsonParser::Show(JsonValue jsonValue) {
  this->PrintJsonValue(std::cout, jsonValue);
  std::cout << std::endl;
}

/**
 * Display a JSON value to an output stream.
 * @param output The output stream.
 * @param jsonValue The JSON value to display.
 */
void JsonParser::PrintJsonValue(std::ostream& output, JsonValue jsonValue) {
  switch (jsonValue.GetType()) {
    case JsonValueType::Null:
      output << "null";
      break;
    case JsonValueType::Number:
      output << jsonValue.GetDouble();
      break;
    case JsonValueType::String:
      output << "\"" << jsonValue.GetString() << "\"";
      break;
    case JsonValueType::Bool:
      output << (jsonValue.GetBool() ? "true" : "false");
      break;
    case JsonValueType::Object: {
      JsonObject& obj = jsonValue.GetObject();
      output << "{";
      bool first = true;
      for (const auto& pair : obj) {
        if (!first) {
          output << ",";
        }
        first = false;
        output << "\"" << pair.first << "\":";
        PrintJsonValue(output, pair.second);
      }
      output << "}";
    } break;
    case JsonValueType::JArray: {
      JsonArray& arr = jsonValue.GetArray();
      output << "[";
      bool first = true;
      for (const auto& value : arr) {
        if (!first) {
          output << ",";
        }
        first = false;
        PrintJsonValue(output, value);
      }
      output << "]";
    } break;
  }
}
}  // namespace fims
#endif

/**
 * @file fims_modules.hpp
 * @brief Rcpp module definitions. Allows for the use of
 * methods::new() in R.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef SRC_FIMS_MODULES_HPP
#define SRC_FIMS_MODULES_HPP

#include "../inst/include/interface/rcpp/rcpp_objects/rcpp_data.hpp"
#include "../inst/include/interface/rcpp/rcpp_objects/rcpp_fleet.hpp"
#include "../inst/include/interface/rcpp/rcpp_objects/rcpp_growth.hpp"
#include "../inst/include/interface/rcpp/rcpp_objects/rcpp_math.hpp"
#include "../inst/include/interface/rcpp/rcpp_objects/rcpp_maturity.hpp"
#include "../inst/include/interface/rcpp/rcpp_objects/rcpp_natural_mortality.hpp"
#include "../inst/include/interface/rcpp/rcpp_objects/rcpp_population.hpp"
#include "../inst/include/interface/rcpp/rcpp_objects/rcpp_recruitment.hpp"
#include "../inst/include/interface/rcpp/rcpp_objects/rcpp_selectivity.hpp"
#include "../inst/include/interface/rcpp/rcpp_objects/rcpp_distribution.hpp"
#include "../inst/include/interface/rcpp/rcpp_objects/rcpp_interface_base.hpp"
#include "../inst/include/interface/rcpp/rcpp_interface.hpp"

RCPP_EXPOSED_CLASS(Parameter)
RCPP_EXPOSED_CLASS(ParameterVector)
RCPP_EXPOSED_CLASS(RealVector)
RCPP_EXPOSED_CLASS(SharedInt)
RCPP_EXPOSED_CLASS(SharedString)
RCPP_EXPOSED_CLASS(SharedReal)
RCPP_EXPOSED_CLASS(SharedBoolean)

/**
 * @brief Define fims C++ functions and classes exposed in R
 *
 * @details
 * The use of `RCPP_MODULE()` allows for exporting of specific C++ code to the
 * R environment, making it callable from R, i.e., providing declarative code
 * of what the module exposes to R.
 *
 * Each element included in the module should have a name, a pointer, and a
 * description separated by commas in that order. Elements can be functions or
 * classes. Within an element, both the name and the description should be
 * wrapped in quotes.
 *
 * The description is printed to the in R when users run `methods::show()` on
 * a function or class within the RCPP_MODULE, e.g., `methods::show(Parameter)`.
 * Thus, information in the description should either link to the relevant
 * doxygen documentation for the C++ class or function or exactly duplicate
 * what is written in the doxygen.
 *
 * Each of the functions included in this module should be exported by manually
 * exporting them in R/FIMS-package.R. Typically, R packages that use C++ would
 * take care a lot of this stuff automatically using `Rcpp::export` calls in the
 * C++ documentation but we cannot do that within FIMS because of how the
 * package is compiled.
 *
 */
RCPP_MODULE(fims) {
  Rcpp::function(
      "CreateTMBModel", &CreateTMBModel,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      // TODO: fix the naming mismatch
      "set_fixed", &set_fixed_parameters,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      // TODO: fix the naming mismatch
      "get_fixed", &get_fixed_parameters_vector,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      // TODO: fix the naming mismatch
      "set_random", &set_random_parameters,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      // TODO: fix the naming mismatch
      "get_random", &get_random_parameters_vector,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      "get_parameter_names", &get_parameter_names,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      "get_random_names", &get_random_names,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      "clear", clear,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      "get_log", get_log,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      "get_log_errors", get_log_errors,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      "get_log_warnings", get_log_warnings,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      "get_log_info", get_log_info,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      "write_log", write_log,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      "set_log_path", set_log_path,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      "init_logging", init_logging,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      "set_log_throw_on_error", set_log_throw_on_error,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      "log_info", log_info,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      "log_warning", log_warning,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      "log_error", log_error,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      // TODO: fix the naming mismatch
      "logit", logit_rcpp,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");
  Rcpp::function(
      // TODO: fix the naming mismatch
      "inv_logit", inv_logit_rcpp,
      "See https://noaa-fims.github.io/FIMS/doxygen/rcpp__interface_8hpp.html.");

  Rcpp::class_<Parameter>(
      "Parameter",
      "See https://noaa-fims.github.io/FIMS/doxygen/classParameter.html.")
      .constructor()
      .constructor<double>()
      .constructor<Parameter>()
      .field("value", &Parameter::initial_value_m)
      .field("estimated_value", &Parameter::final_value_m)
      .field("id", &Parameter::id_m)
      .field("estimation_type", &Parameter::estimation_type_m);

  Rcpp::class_<ParameterVector>(
      "ParameterVector",
      "See https://noaa-fims.github.io/FIMS/doxygen/classParameterVector.html.")
      .constructor()
      .constructor<size_t>()
      .constructor<Rcpp::NumericVector, size_t>()
      .method("get", &ParameterVector::get)
      .method("set", &ParameterVector::set)
      .method("show", &ParameterVector::show)
      .method("at", &ParameterVector::at)
      .method("size", &ParameterVector::size)
      .method("resize", &ParameterVector::resize)
      .method("set_all_estimable", &ParameterVector::set_all_estimable)
      .method("set_all_random", &ParameterVector::set_all_random)
      .method("fill", &ParameterVector::fill)
      .method("get_id", &ParameterVector::get_id);

  Rcpp::class_<RealVector>(
      "RealVector",
      "See https://noaa-fims.github.io/FIMS/doxygen/classRealVector.html.")
      .constructor()
      .constructor<size_t>()
      .constructor<Rcpp::NumericVector, size_t>()
      .method("get", &RealVector::get)
      .method("set", &RealVector::set)
      .method("fromRVector", &RealVector::fromRVector)
      .method("toRVector", &RealVector::toRVector)
      .method("show", &RealVector::show)
      .method("at", &RealVector::at)
      .method("size", &RealVector::size)
      .method("resize", &RealVector::resize)
      .method("get_id", &RealVector::get_id);

  Rcpp::class_<SharedInt>(
      "SharedInt",
      "See https://noaa-fims.github.io/FIMS/doxygen/classSharedInt.html.")
      .constructor()
      .constructor<int>()
      .method("get", &SharedInt::get)
      .method("set", &SharedInt::set);

  Rcpp::class_<SharedString>(
      "SharedString",
      "See https://noaa-fims.github.io/FIMS/doxygen/classSharedString.html.")
      .constructor()
      .constructor<std::string>()
      .method("get", &SharedString::get)
      .method("set", &SharedString::set);

  Rcpp::class_<SharedBoolean>(
      "SharedBoolean",
      "See https://noaa-fims.github.io/FIMS/doxygen/classSharedBoolean.html.")
      .constructor()
      .constructor<bool>()
      .method("get", &SharedBoolean::get)
      .method("set", &SharedBoolean::set);

  Rcpp::class_<SharedReal>(
      "SharedReal",
      "See https://noaa-fims.github.io/FIMS/doxygen/classSharedReal.html.")
      .constructor()
      .constructor<double>()
      .method("get", &SharedReal::get)
      .method("set", &SharedReal::set);

  Rcpp::class_<BevertonHoltRecruitmentInterface>(
      "BevertonHoltRecruitment",
      "See "
      "https://noaa-fims.github.io/FIMS/doxygen/"
      "classBevertonHoltRecruitmentInterface.html.")
      .constructor()
      .field("logit_steep", &BevertonHoltRecruitmentInterface::logit_steep)
      .field("log_rzero", &BevertonHoltRecruitmentInterface::log_rzero)
      .field("log_devs", &BevertonHoltRecruitmentInterface::log_devs)
      .field("log_r", &BevertonHoltRecruitmentInterface::log_r)
      .field("log_expected_recruitment",
             &BevertonHoltRecruitmentInterface::log_expected_recruitment)
      .field("n_years", &BevertonHoltRecruitmentInterface::n_years)
      .method("get_id", &BevertonHoltRecruitmentInterface::get_id)
      .method("SetRecruitmentProcessID",
              &BevertonHoltRecruitmentInterface::SetRecruitmentProcessID)
      .method("evaluate_mean",
              &BevertonHoltRecruitmentInterface::evaluate_mean);

  Rcpp::class_<LogDevsRecruitmentInterface>(
      "LogDevsRecruitmentProcess",
      "See "
      "https://noaa-fims.github.io/FIMS/doxygen/"
      "classLogDevsRecruitmentInterface.html.")
      .constructor()
      .method("get_id", &LogDevsRecruitmentInterface::get_id)
      .method("evaluate_process",
              &LogDevsRecruitmentInterface::evaluate_process);

  Rcpp::class_<LogRRecruitmentInterface>(
      "LogRRecruitmentProcess",
      "See "
      "https://noaa-fims.github.io/FIMS/doxygen/classLogRRecruitmentInterface.html.")
      .constructor()
      .method("get_id", &LogRRecruitmentInterface::get_id)
      .method("evaluate_process", &LogRRecruitmentInterface::evaluate_process);

  Rcpp::class_<FleetInterface>(
      "Fleet",
      "See https://noaa-fims.github.io/FIMS/doxygen/classFleetInterface.html.")
      .constructor()
      .field("log_q", &FleetInterface::log_q)
      .field("log_Fmort", &FleetInterface::log_Fmort)
      .field("n_ages", &FleetInterface::n_ages)
      .field("n_years", &FleetInterface::n_years)
      .field("n_lengths", &FleetInterface::n_lengths)
      .field("observed_landings_units",
             &FleetInterface::observed_landings_units)
      .field("observed_index_units", &FleetInterface::observed_index_units)
      .field("index_expected", &FleetInterface::derived_index_expected)
      .field("landings_expected", &FleetInterface::derived_landings_expected)
      .field("log_index_expected", &FleetInterface::log_index_expected)
      .field("log_landings_expected", &FleetInterface::log_landings_expected)
      .field("agecomp_expected", &FleetInterface::agecomp_expected)
      .field("lengthcomp_expected", &FleetInterface::lengthcomp_expected)
      .field("agecomp_proportion", &FleetInterface::agecomp_proportion)
      .field("lengthcomp_proportion", &FleetInterface::lengthcomp_proportion)
      .field("age_to_length_conversion",
             &FleetInterface::age_to_length_conversion)
      .method("get_id", &FleetInterface::get_id)
      .method("SetName", &FleetInterface::SetName)
      .method("GetName", &FleetInterface::GetName)
      .method("SetObservedAgeCompDataID",
              &FleetInterface::SetObservedAgeCompDataID)
      .method("GetObservedAgeCompDataID",
              &FleetInterface::GetObservedAgeCompDataID)
      .method("SetObservedLengthCompDataID",
              &FleetInterface::SetObservedLengthCompDataID)
      .method("GetObservedLengthCompDataID",
              &FleetInterface::GetObservedLengthCompDataID)
      .method("SetObservedIndexDataID", &FleetInterface::SetObservedIndexDataID)
      .method("GetObservedIndexDataID", &FleetInterface::GetObservedIndexDataID)
      .method("SetObservedLandingsDataID",
              &FleetInterface::SetObservedLandingsDataID)
      .method("GetObservedLandingsDataID",
              &FleetInterface::GetObservedLandingsDataID)
      .method("SetSelectivityID", &FleetInterface::SetSelectivityID);

  Rcpp::class_<AgeCompDataInterface>(
      "AgeComp",
      "See https://noaa-fims.github.io/FIMS/doxygen/classAgeCompDataInterface.html.")
      .constructor<int, int>()
      .field("age_comp_data", &AgeCompDataInterface::age_comp_data)
      .method("get_id", &AgeCompDataInterface::get_id);

  Rcpp::class_<LengthCompDataInterface>(
      "LengthComp",
      "See "
      "https://noaa-fims.github.io/FIMS/doxygen/classLengthCompDataInterface.html.")
      .constructor<int, int>()
      .field("length_comp_data", &LengthCompDataInterface::length_comp_data)
      .method("get_id", &LengthCompDataInterface::get_id);

  Rcpp::class_<LandingsDataInterface>(
      "Landings",
      "See "
      "https://noaa-fims.github.io/FIMS/doxygen/classLandingsDataInterface.html.")
      .constructor<int>()
      .field("landings_data", &LandingsDataInterface::landings_data)
      .method("get_id", &LandingsDataInterface::get_id);

  Rcpp::class_<IndexDataInterface>(
      "Index",
      "See https://noaa-fims.github.io/FIMS/doxygen/classIndexDataInterface.html.")
      .constructor<int>()
      .field("index_data", &IndexDataInterface::index_data)
      .method("get_id", &IndexDataInterface::get_id);

  Rcpp::class_<PopulationInterface>(
      "Population",
      "See https://noaa-fims.github.io/FIMS/doxygen/classPopulationInterface.html.")
      .constructor()
      .method("get_id", &PopulationInterface::get_id)
      .field("n_ages", &PopulationInterface::n_ages)
      .field("n_fleets", &PopulationInterface::n_fleets)
      .field("n_years", &PopulationInterface::n_years)
      .field("n_lengths", &PopulationInterface::n_lengths)
      .field("log_M", &PopulationInterface::log_M)
      .field("log_f_multiplier", &PopulationInterface::log_f_multiplier)
      .field("spawning_biomass_ratio",
             &PopulationInterface::spawning_biomass_ratio)
      .field("log_init_naa", &PopulationInterface::log_init_naa)
      .field("ages", &PopulationInterface::ages)
      .method("SetMaturityID", &PopulationInterface::SetMaturityID)
      .method("SetGrowthID", &PopulationInterface::SetGrowthID)
      .method("SetRecruitmentID", &PopulationInterface::SetRecruitmentID)
      .method("AddFleet", &PopulationInterface::AddFleet)
      .method("SetName", &PopulationInterface::SetName)
      .method("GetName", &PopulationInterface::GetName);

  Rcpp::class_<LogisticMaturityInterface>(
      "LogisticMaturity",
      "See "
      "https://noaa-fims.github.io/FIMS/doxygen/"
      "classLogisticMaturityInterface.html.")
      .constructor()
      .field("inflection_point", &LogisticMaturityInterface::inflection_point)
      .field("slope", &LogisticMaturityInterface::slope)
      .method("get_id", &LogisticMaturityInterface::get_id)
      .method("evaluate", &LogisticMaturityInterface::evaluate);

  Rcpp::class_<LogisticSelectivityInterface>(
      "LogisticSelectivity",
      "See "
      "https://noaa-fims.github.io/FIMS/doxygen/"
      "classLogisticSelectivityInterface.html.")
      .constructor()
      .field("inflection_point",
             &LogisticSelectivityInterface::inflection_point)
      .field("slope", &LogisticSelectivityInterface::slope)
      .method("get_id", &LogisticSelectivityInterface::get_id)
      .method("evaluate", &LogisticSelectivityInterface::evaluate);

  Rcpp::class_<DoubleLogisticSelectivityInterface>(
      "DoubleLogisticSelectivity",
      "See "
      "https://noaa-fims.github.io/FIMS/doxygen/"
      "classDoubleLogisticSelectivityInterface.html.")
      .constructor()
      .field("inflection_point_asc",
             &DoubleLogisticSelectivityInterface::inflection_point_asc)
      .field("slope_asc", &DoubleLogisticSelectivityInterface::slope_asc)
      .field("inflection_point_desc",
             &DoubleLogisticSelectivityInterface::inflection_point_desc)
      .field("slope_desc", &DoubleLogisticSelectivityInterface::slope_desc)
      .method("get_id", &DoubleLogisticSelectivityInterface::get_id)
      .method("evaluate", &DoubleLogisticSelectivityInterface::evaluate);

  Rcpp::class_<EWAAGrowthInterface>(
      "EWAAGrowth",
      "See https://noaa-fims.github.io/FIMS/doxygen/classEWAAGrowthInterface.html.")
      .constructor()
      .field("ages", &EWAAGrowthInterface::ages, "Ages for each age class.")
      .field("weights", &EWAAGrowthInterface::weights,
             "Weights for each age class.")
      .field("n_years", &EWAAGrowthInterface::n_years, "Number of years.")
      .method("get_id", &EWAAGrowthInterface::get_id)
      .method("evaluate", &EWAAGrowthInterface::evaluate);

  Rcpp::class_<DnormDistributionsInterface>(
      "DnormDistribution",
      "See "
      "https://noaa-fims.github.io/FIMS/doxygen/"
      "classDnormDistributionsInterface.html.")
      .constructor()
      .method("get_id", &DnormDistributionsInterface::get_id)
      .method("evaluate", &DnormDistributionsInterface::evaluate)
      .method("set_observed_data",
              &DnormDistributionsInterface::set_observed_data)
      .method("set_distribution_mean",
              &DnormDistributionsInterface::set_distribution_mean)
      .method("set_distribution_links",
              &DnormDistributionsInterface::set_distribution_links)
      .field("observed_values", &DnormDistributionsInterface::observed_values)
      .field("expected_values", &DnormDistributionsInterface::expected_values)
      .field("expected_mean", &DnormDistributionsInterface::expected_mean)
      .field("log_sd", &DnormDistributionsInterface::log_sd);

  Rcpp::class_<DlnormDistributionsInterface>(
      "DlnormDistribution",
      "See "
      "https://noaa-fims.github.io/FIMS/doxygen/"
      "classDlnormDistributionsInterface.html.")
      .constructor()
      .method("get_id", &DlnormDistributionsInterface::get_id)
      .method("evaluate", &DlnormDistributionsInterface::evaluate)
      .method("set_observed_data",
              &DlnormDistributionsInterface::set_observed_data)
      .method("set_distribution_links",
              &DlnormDistributionsInterface::set_distribution_links)
      .field("observed_values", &DlnormDistributionsInterface::observed_values)
      .field("expected_values", &DlnormDistributionsInterface::expected_values)
      .field("log_sd", &DlnormDistributionsInterface::log_sd);

  Rcpp::class_<DmultinomDistributionsInterface>(
      "DmultinomDistribution",
      "See "
      "https://noaa-fims.github.io/FIMS/doxygen/"
      "classDmultinomDistributionsInterface.html.")
      .constructor()
      .method("get_id", &DmultinomDistributionsInterface::get_id)
      .method("evaluate", &DmultinomDistributionsInterface::evaluate)
      .method("set_observed_data",
              &DmultinomDistributionsInterface::set_observed_data)
      .method("set_distribution_links",
              &DmultinomDistributionsInterface::set_distribution_links)
      .method("set_note", &DmultinomDistributionsInterface::set_note)
      .field("observed_values",
             &DmultinomDistributionsInterface::observed_values)
      .field("expected_values",
             &DmultinomDistributionsInterface::expected_values)
      .field("dims", &DmultinomDistributionsInterface::dims);

  Rcpp::class_<CatchAtAgeInterface>(
      "CatchAtAge",
      "See https://noaa-fims.github.io/FIMS/doxygen/classCatchAtAgeInterface.html.")
      .constructor()
      .method("AddPopulation", &CatchAtAgeInterface::AddPopulation)
      .method("get_output", &CatchAtAgeInterface::to_json)
      .method("GetId", &CatchAtAgeInterface::get_id)
      .method("DoReporting", &CatchAtAgeInterface::DoReporting)
      .method("IsReporting", &CatchAtAgeInterface::IsReporting);
}

#endif /* SRC_FIMS_MODULES_HPP */


#include <cmath>

#include "../inst/include/interface/rcpp/rcpp_interface.hpp"
#include "../inst/include/interface/interface.hpp"
#include "init.hpp"
#include "fims_modules.hpp"
#include "../inst/include/common/model.hpp"

/// @cond
/**
 * @brief TMB objective function
 *
 * @return Returns a joint negative log likelihood
 */
template<class Type>
Type objective_function<Type>::operator()() {


    PARAMETER_VECTOR(p);
    PARAMETER_VECTOR(re);

    // code below copied from ModularTMBExample/src/tmb_objective_function.cpp

    // get the singleton instance for Model Class
    std::shared_ptr<fims_model::Model<Type>> model =
      fims_model::Model<Type>::GetInstance();
    // get the singleton instance for Information Class
    std::shared_ptr<fims_info::Information<Type>> information =
      fims_info::Information<Type>::GetInstance();

    //update the fixed effects parameter values
    for(size_t i =0; i < information->fixed_effects_parameters.size(); i++){
        *information->fixed_effects_parameters[i] = p[i];
    }
    //update the random effects parameter values
    for(size_t i =0; i < information->random_effects_parameters.size(); i++){
        *information->random_effects_parameters[i] = re[i];
    }
    model -> of = this;

    Type nll = 0;
    //evaluate the model objective function value
    try{
      nll = model->Evaluate();
    } catch (const std::exception& e) {
      Rf_error("Error during model evaluation: %s",  std::string(e.what()).c_str());
    }

    return nll;

}
/// @endcond

/**
 * @file init.hpp
 * @brief An interface to dynamically load the functions.
 * @copyright This file is part of the NOAA, National Marine Fisheries Service
 * Fisheries Integrated Modeling System project. See LICENSE in the source
 * folder for reuse information.
 */
#ifndef SRC_INIT_HPP
#define SRC_INIT_HPP
#include <R_ext/Rdynload.h>
#include <stdlib.h>

extern "C" {

/**
 * @brief TODO: Handles the initialization of the fims rcpp module.
 *
 * @return SEXP
 */
SEXP _rcpp_module_boot_fims();

/**
 * @brief Callback definition to load the FIMS module.
 */
static const R_CallMethodDef CallEntries[] = {
    TMB_CALLDEFS,
    {"_rcpp_module_boot_fims", (DL_FUNC)&_rcpp_module_boot_fims, 0},
    {NULL, NULL, 0}};

/**
 * @brief FIMS shared object initializer.
 * @param dll TODO: provide a brief description.
 *
 */
void R_init_FIMS(DllInfo *dll) {
  R_registerRoutines(dll, NULL, CallEntries, NULL, NULL);
  R_useDynamicSymbols(dll, FALSE);
#ifdef TMB_CCALLABLES
  TMB_CCALLABLES("FIMS");
#endif
}
}

#endif  // SRC_INIT_HPP

1		#' Validity checks for distributions
2		#'
3		#' This function checks the validity of arguments passed to functions that
4		#' relate to distributions within the Fisheries Integrated Modeling System
5		#' (FIMS). This function is designed to fail early only once, otherwise it goes
6		#' through many checks before reporting the results in an attempt to give the
7		#' user the most information possible. If it were to fail on every mistake,
8		#' then the user might have to iterate through multiple changes to their input
9		#' values. Sometimes, their mistakes might take quite a bit of time to make it
10		#' to this function or worse they might be running things on the cloud and not
11		#' have immediate access to the report. Therefore, we feel that providing the
12		#' most information possible is the best way forward.
13		#'
14		#' @param args A named list of input arguments that must contain at least
15		#' `family` and `sd`. `data_type` is only needed for some upstream functions.
16		#' @seealso
17		#' This function is used in the following functions:
18		#' * [initialize_data_distribution()]
19		#' * [initialize_process_distribution()]
20		#' @noRd
21		#' @return
22		#' If successful, `TRUE` is invisibly returned. If unsuccessful,
23		#' [cli::cli_abort()] is used to return the relevant error messages.
24		check_distribution_validity <- function(args) {
25		# Separate objects from args
26	130x	family <- args[["family"]]
27	130x	sd <- args[["sd"]]
28		# Optional argument data_type
29	130x	data_type <- args[["data_type"]]
30	130x	check_present <- purrr::map_vec(list("family" = family, "sd" = sd), is.null)
31
32		# Set up global rules
33		# FIXME: Move this to a data item in the package so it can be used everywhere
34		# Could do a call to all data objects in the package and get unique types that
35		# are available
36	130x	data_type_names <- c("landings", "index", "agecomp", "lengthcomp")
37	130x	if (is.null(data_type)) {
38	25x	available_distributions <- c("lognormal", "gaussian")
39		} else {
40	105x	available_distributions <- switch(
41	105x	EXPR = ifelse(grepl("comp", data_type), "composition", data_type),
42	105x	"landings" = c("lognormal", "gaussian"),
43	105x	"index" = c("lognormal", "gaussian"),
44	105x	"composition" = c("multinomial"),
45	105x	"unavailable data type"
46		)
47		}
48	130x	elements_of_sd <- c("value", "estimation_type")
49
50		# Start a bulleted list of errors and add to it in each if statement
51	130x	abort_bullets <- c(
52	130x	" " = "The following errors were found in the input argument {.var args}."
53		)
54	130x	if (any(check_present)) {
55	1x	bad <- names(check_present[unlist(check_present)])
56	1x	abort_bullets <- c(
57	1x	abort_bullets,
58	1x	"x" = "{.var {bad}} {cli::qty(length(bad))} {?is/are} missing from
59	1x	{.var args}."
60		)
61		# Abort early because not all of the necessary items were in args
62	1x	cli::cli_abort(abort_bullets)
63		}
64
65		# Checks related to the family class
66	129x	if (!inherits(family, "family")) {
67	1x	abort_bullets <- c(
68	1x	abort_bullets,
69	1x	"x" = "The class of {.var family} is incorrect.",
70	1x	"i" = "{.var family} should be an object of class {.var family},
71	1x	e.g., `family = gaussian()`, instead of {class(family)}."
72		)
73		} else {
74		if (
75	128x	!(family[["family"]] %in% available_distributions) \|\|
76	128x	"unavailable data type" %in% available_distributions
77		) {
78	6x	ifelse_type <- ifelse(
79	6x	is.null(data_type),
80	6x	"distribution",
81	6x	paste(data_type, "data")
82		)
83	6x	abort_bullets <- c(
84	6x	abort_bullets,
85	6x	"x" = "FIMS currently does not allow the family to be
86	6x	{.code {family[['family']]}}.",
87	6x	"i" = "The families available for this {ifelse_type} are
88	6x	{.code {available_distributions}}."
89		)
90		}
91		}
92
93		# Checks related to the type of data
94	129x	if (!is.null(data_type)) {
95	104x	if (!(data_type %in% data_type_names)) {
96	!	abort_bullets <- c(
97	!	abort_bullets,
98	!	"x" = "The specified {.var data_type} of {.var {data_type}} is not
99	!	available.",
100	!	"i" = "Allowed values for {.var data_type} are
101	!	{.code {data_type_names}}."
102		)
103		}
104		}
105
106		# Checks related to standard deviation
107		# Check if sd has both elements and if yes, then go onto the else statement
108		# for major checks
109	129x	if (!all(elements_of_sd %in% names(sd))) {
110	2x	abort_bullets <- c(
111	2x	abort_bullets,
112	2x	"x" = "{.var {elements_of_sd}} need to be present in sd.",
113	2x	"i" = "Only {.code {names(sd)}} {cli::qty(length(sd))} {?is/are} present."
114		)
115		} else {
116	127x	if (!all(sd[["value"]] > 0, na.rm = TRUE)) {
117	1x	abort_bullets <- c(
118	1x	abort_bullets,
119	1x	"x" = "Values passed to {.var sd} are out of bounds.",
120	1x	"i" = "Values passed to {.var sd} {cli::qty(length(sd[['value']]))}
121	1x	{?is/are} {.code {sd[['value']]}}.",
122	1x	"i" = "All standard deviation (sd) values need to be positive."
123		)
124		}
125		if (
126	127x	length(sd[["estimation_type"]]) > 1 &&
127	127x	length(sd[["value"]]) != length(sd[["estimation_type"]])
128		) {
129	2x	sd_length <- length(sd[["value"]])
130	2x	est_length <- length(sd[["estimation_type"]])
131	2x	abort_bullets <- c(
132	2x	abort_bullets,
133	2x	"x" = "The sizes of {.var value} and {.var estimation_type} within {.var sd}
134	2x	must match if more than one value is specified for the latter.",
135	2x	"i" = "The length of {.var sd[['value']]} is {.code {sd_length}}.",
136	2x	"i" = "The length of {.var sd[['estimation_type']]} is
137	2x	{.code {est_length}}."
138		)
139		}
140		}
141
142		# Check dimensions for data distributions: sd must be either length 1 (scalar)
143		# or match data length when data_type is landings or index
144	129x	if (!is.null(data_type) && !is.null(args[["module"]])) {
145	104x	module <- args[["module"]]
146	104x	if (data_type == "landings" \| data_type == "index") {
147	42x	n_obs <- module$n_years$get()
148
149	42x	if (length(sd[["value"]]) > 1 && length(sd[["value"]]) != n_obs) {
150	2x	abort_bullets <- c(
151	2x	abort_bullets,
152	2x	"x" = "The size of {.var log_sd} does not match the size of observed data for {data_type}.",
153	2x	"i" = "The {.var log_sd} vector is of size {length(sd[['value']])}.",
154	2x	"i" = "The observed {data_type} data vector is of size {n_obs}.",
155	2x	"i" = "Either provide a single {.var log_sd} value (scalar) or a vector matching the data length."
156		)
157		}
158		}
159		}
160
161		# Return error messages if more than just the default is present
162	129x	if (length(abort_bullets) == 1) {
163	115x	invisible(TRUE)
164		} else {
165	14x	cli::cli_abort(abort_bullets)
166		}
167		}
168
169		#' Return name of expected value
170		#'
171		#' The combination of data type, family, and link lead to a specific name for
172		#' the expected value within the code base. This function looks at the
173		#' combination of these three objects and specifies the appropriate string for
174		#' its name going forward.
175		#' @inheritParams initialize_data_distribution
176		#' @noRd
177		#' @return
178		#' A string specifying the name of the expected value.
179		#'
180		get_expected_name <- function(family, data_type) {
181		# TODO: Think about if the name of the expected value should change based on
182		# the link or if it should stay the same? Keeping track of different names in
183		# the code base might be too complex for the output as well
184	96x	family_string <- family[["family"]]
185	96x	link_string <- family[["link"]]
186	96x	expected_name <- dplyr::case_when(
187	96x	data_type == "landings" &&
188	96x	grepl("lognormal\|gaussian", family_string) &&
189	96x	link_string == "log" ~ "log_landings_expected",
190	96x	data_type == "landings" &&
191	96x	grepl("lognormal\|gaussian", family_string) &&
192	96x	link_string == "identity" ~ "landings_expected",
193	96x	data_type == "index" &&
194	96x	grepl("lognormal\|gaussian", family_string) &&
195	96x	link_string == "log" ~ "log_index_expected",
196	96x	data_type == "index" &&
197	96x	grepl("lognormal\|gaussian", family_string) &&
198	96x	link_string == "identity" ~ "index_expected",
199	96x	grepl("agecomp", data_type) ~ "agecomp_proportion",
200	96x	grepl("lengthcomp", data_type) ~ "lengthcomp_proportion",
201		)
202		# Check combination of entries was okay and led to valid name
203	96x	if (is.na(expected_name)) {
204	!	cli::cli_abort(c(
205	!	"x" = "The combination of data type, family, and link are incompatible in
206	!	some way.",
207	!	"i" = "{.var data_type} is {.var {data_type}}.",
208	!	"i" = "The family is {.var {family_string}}.",
209	!	"i" = "The link is {.var {link_string}}."
210		))
211		}
212	96x	return(expected_name)
213		}
214
215		#' Set up a new distribution for a data type or a process
216		#'
217		#' Use [methods::new()] to set up a distribution within an existing module with
218		#' the necessary linkages between the two. For example, a fleet module will need
219		#' a distributional assumption for parts of the data associated with it, which
220		#' requires the use of `initialize_data_distribution()`, and a recruitment
221		#' module, like the Beverton--Holt stock--recruit relationship, will need a
222		#' distribution associated with the recruitment deviations, which requires
223		#' `initialize_process_distribution()`.
224		#' @param module An identifier to a C++ fleet module that is linked to the data
225		#' of interest.
226		#' @param family A description of the error distribution and link function to
227		#' be used in the model. The argument takes a family class, e.g.,
228		#' `stats::gaussian(link = "identity")`.
229		#' @param sd A list of length two. The first entry is named `"value"` and it
230		#' stores the initial values (scalar or vector) for the relevant standard
231		#' deviations. The default is `value = 1`. The second entry is named
232		#' `"estimation_type"` and it stores a vector of booleans (default = "constant") is a
233		#' string indicating whether or not standard deviation is estimated as a fixed effect
234		#' or held constant. If `"value"` is a vector and `"estimation_type"` is a scalar,
235		#' the single value specified `"estimation_type"` value will be repeated to match the length of
236		#' `value`. Otherwise, the dimensions of the two must match.
237		#' @param data_type A string specifying the type of data that the
238		#' distribution will be fit to. Allowable types include
239		#' `r toString(formals(initialize_data_distribution)[["data_type"]])`
240		#' and the default is
241		#' `r toString(formals(initialize_data_distribution)[["data_type"]][1])`.
242		#' @param par A string specifying the parameter name the distribution applies
243		#' to. Parameters must be members of the specified module. Use
244		#' `methods::show(module)` to obtain names of parameters within the module.
245		#' @param is_random_effect A boolean indicating whether or not the process is
246		#' estimated as a random effect.
247		#' @return
248		#' A reference class. is returned. Use [methods::show()] to view the various
249		#' Rcpp class fields, methods, and documentation.
250		#' @keywords distribution
251		#' @export
252		#' @examples
253		#' \dontrun{
254		#' # Set up a new data distribution
255		#' n_years <- 30
256		#' # Create a new fleet module
257		#' fleet <- methods::new(Fleet)
258		#' # Create a distribution for the fleet module
259		#' fleet_distribution <- initialize_data_distribution(
260		#' module = fishing_fleet,
261		#' family = lognormal(link = "log"),
262		#' sd = list(
263		#' value = rep(sqrt(log(0.01^2 + 1)), n_years),
264		#' estimation_type = rep("constant", n_years) # Could also be a single "constant"
265		#' ),
266		#' data_type = "index"
267		#' )
268		#'
269		#' # Set up a new process distribution
270		#' # Create a new recruitment module
271		#' recruitment <- methods::new(BevertonHoltRecruitment)
272		#' # view parameter names of the recruitment module
273		#' methods::show(BevertonHoltRecruitment)
274		#' # Create a distribution for the recruitment module
275		#' recruitment_distribution <- initialize_process_distribution(
276		#' module = recruitment,
277		#' par = "log_devs",
278		#' family = gaussian(),
279		#' sd = list(value = 0.4, estimation_type = "constant"),
280		#' is_random_effect = FALSE
281		#' )
282		#' }
283		initialize_data_distribution <- function(
284		module,
285		family = NULL,
286		# Create a tibble with value and estimation_type column for sd
287		sd = tibble::tibble(
288		value = 1,
289		estimation_type = "constant"
290		),
291		# FIXME: Move this argument to second to match where par is in
292		# initialize_process_distribution
293		data_type = c("landings", "index", "agecomp", "lengthcomp")
294		) {
295	106x	data_type <- rlang::arg_match(data_type)
296		# FIXME: Make the available families a data object
297		# Could also make the matrix of distributions available per type as a
298		# data frame where the check could use the stored object.
299
300		# validity check on user input
301	105x	args <- list(
302	105x	family = family,
303	105x	sd = sd,
304	105x	data_type = data_type,
305	105x	module = module
306		)
307	105x	check_distribution_validity(args)
308
309		# assign name of observed data based on data_type
310	96x	obs_id_name <- glue::glue("observed_{data_type}_data_id")
311
312		# Set up distribution based on `family` argument`
313	96x	if (family[["family"]] == "lognormal") {
314		# create new Rcpp module
315	37x	new_module <- methods::new(DlnormDistribution)
316
317		# populate logged standard deviation parameter with log of input
318		# Using resize() and then assigning value to each element of log_sd directly
319		# is correct, as creating a new ParameterVector for log_sd here would
320		# trigger an error in integration tests with wrappers.
321	37x	new_module$log_sd$resize(length(sd[["value"]]))
322
323	37x	purrr::walk(
324	37x	seq_along(sd[["value"]]),
325	37x	\(x) new_module[["log_sd"]][x][["value"]] <- log(sd[["value"]][x])
326		)
327
328	37x	purrr::walk(
329	37x	seq_along(sd[["estimation_type"]]),
330	37x	\(x) new_module[["log_sd"]][x][["estimation_type"]]$set(sd[["estimation_type"]][x])
331		)
332		}
333
334	96x	if (family[["family"]] == "gaussian") {
335		# create new Rcpp module
336	1x	new_module <- methods::new(DnormDistribution)
337
338		# populate logged standard deviation parameter with log of input
339	1x	purrr::walk(
340	1x	seq_along(sd[["value"]]),
341	1x	\(x) new_module[["log_sd"]][x][["value"]] <- log(sd[["value"]][x])
342		)
343
344	1x	purrr::walk(
345	1x	seq_along(sd[["estimation_type"]]),
346	1x	\(x) new_module[["log_sd"]][x][["estimation_type"]]$set(sd[["estimation_type"]][x])
347		)
348		}
349
350	96x	if (family[["family"]] == "multinomial") {
351		# create new Rcpp module
352	58x	new_module <- methods::new(DmultinomDistribution)
353		}
354
355		# setup link to observed data
356	96x	if (data_type == "landings") {
357	18x	new_module$set_observed_data(module$GetObservedLandingsDataID())
358		}
359	96x	if (data_type == "index") {
360	20x	new_module$set_observed_data(module$GetObservedIndexDataID())
361		}
362	96x	if (data_type == "agecomp") {
363	32x	new_module$set_observed_data(module$GetObservedAgeCompDataID())
364		}
365	96x	if (data_type == "lengthcomp") {
366	26x	new_module$set_observed_data(module$GetObservedLengthCompDataID())
367		}
368
369		# set name of expected values
370	96x	expected <- get_expected_name(family, data_type)
371		# setup link to expected values
372	96x	new_module$set_distribution_links("data", module$field(expected)$get_id())
373
374	96x	return(new_module)
375		}
376
377		#' @rdname initialize_data_distribution
378		#' @keywords distribution
379		#' @export
380		initialize_process_distribution <- function(
381		module,
382		par,
383		family = NULL,
384		sd = tibble::tibble(
385		value = 1,
386		estimation_type = "constant"
387		),
388		is_random_effect = FALSE
389		) {
390		# validity check on user input
391	25x	args <- list(family = family, sd = sd)
392	25x	check_distribution_validity(args)
393
394	19x	expected <- switch(paste0(par, "_", class(module)),
395	19x	"log_devs_Rcpp_BevertonHoltRecruitment" = NULL,
396	19x	"log_r_Rcpp_BevertonHoltRecruitment" = "log_expected_recruitment"
397		)
398
399		# Set up distribution based on `family` argument`
400	19x	if (family[["family"]] == "lognormal") {
401		# create new Rcpp module
402	!	new_module <- methods::new(DlnormDistribution)
403
404		# populate logged standard deviation parameter with log of input
405	!	new_module$log_sd$resize(length(sd[["value"]]))
406	!	purrr::walk(
407	!	seq_along(sd[["value"]]),
408	!	\(x) new_module[["log_sd"]][x][["value"]] <- log(sd[["value"]][x])
409		)
410
411		# setup whether or not sd parameter is estimated
412	!	if (length(sd[["value"]]) > 1 && length(sd[["estimation_type"]]) == 1) {
413	!	if (sd[["estimation_type"]] == "constant") {
414	!	new_module$log_sd$set_all_estimable(FALSE)
415		} else {
416	!	new_module$log_sd$set_all_estimable(TRUE)
417		}
418		} else {
419	!	for (i in seq_along(sd[["estimation_type"]])) {
420	!	new_module$log_sd[i]$estimation_type$set(sd[["estimation_type"]][i])
421		}
422		}
423		}
424
425	19x	if (family[["family"]] == "gaussian") {
426		# create new Rcpp module
427	19x	new_module <- methods::new(DnormDistribution)
428
429		# populate logged standard deviation parameter with log of input
430	19x	new_module$log_sd$resize(length(sd[["value"]]))
431	19x	for (i in seq_along(sd[["value"]])) {
432	19x	new_module$log_sd[i]$value <- log(sd[["value"]][i])
433		}
434
435		# setup whether or not sd parameter is estimated
436	19x	if (length(sd[["value"]]) > 1 && length(sd[["estimation_type"]]) == 1) {
437	!	if (sd[["estimation_type"]] == "constant") {
438	!	new_module$log_sd$set_all_estimable(FALSE)
439		} else {
440	!	new_module$log_sd$set_all_estimable(TRUE)
441		}
442		} else {
443	19x	for (i in seq_along(sd[["estimation_type"]])) {
444	19x	new_module$log_sd[i]$estimation_type$set(sd[["estimation_type"]][i])
445		}
446		}
447		}
448
449
450	19x	n_dim <- length(module$field(par))
451
452		# create new Rcpp modules
453	19x	new_module$observed_values$resize(n_dim)
454	19x	new_module$expected_values$resize(n_dim)
455
456		# initialize values with 0
457		# these are overwritten in the code later by user input
458	19x	for (i in 1:n_dim) {
459	551x	new_module$observed_values[i]$value <- 0
460	551x	new_module$expected_values[i]$value <- 0
461		}
462
463		# setup links to parameter
464	19x	if (is.null(expected)) {
465	19x	new_module$set_distribution_links(
466	19x	"random_effects",
467	19x	module$field(par)$get_id()
468		)
469		} else {
470	!	new_module$set_distribution_links(
471	!	"random_effects",
472	!	c(
473	!	module$field(par)$get_id(),
474	!	module$field(expected)$get_id()
475		)
476		)
477		}
478
479	19x	return(new_module)
480		}
481
482		#' @rdname initialize_data_distribution
483		#' @keywords distribution
484		#' @export
485		initialize_process_structure <- function(module, par) {
486	18x	new_process_module <- switch(paste0(par, "_", class(module)),
487	18x	"log_devs_Rcpp_BevertonHoltRecruitment" = new(LogDevsRecruitmentProcess),
488	18x	"log_r_Rcpp_BevertonHoltRecruitment" = new(LogRRecruitmentProcess)
489		)
490
491	18x	module$SetRecruitmentProcessID(new_process_module$get_id())
492
493	18x	return(new_process_module)
494		}
495
496		#' Distributions not available in the stats package
497		#'
498		#' Family objects provide a convenient way to specify the details of the models
499		#' used by functions such as [stats::glm()]. These functions within this
500		#' package are not available within the stats package but are designed in a
501		#' similar manner.
502		#'
503		#' @param link A string specifying the model link function. For example,
504		#' `"identity"` or `"log"` are appropriate names for the [stats::gaussian()]
505		#' distribution. `"log"` and `"logit"` are the defaults for the lognormal and
506		#' the multinomial, respectively.
507		#' @return
508		#' An object of class `family` (which has a concise print method). This
509		#' particular family has a truncated length compared to other distributions in
510		#' [stats::family()].
511		#' \item{family}{character: the family name.}
512		#' \item{link}{character: the link name.}
513		#'
514		#' @seealso
515		#' * [stats::family()]
516		#' * [stats::gaussian()]
517		#' * [stats::glm()]
518		#' * [stats::power()]
519		#' * [stats::make.link()]
520		#' @keywords distribution
521		#' @export
522		#' @examples
523		#' a_family <- multinomial()
524		#' a_family[["family"]]
525		#' a_family[["link"]]
526		lognormal <- function(link = "log") {
527	40x	family_class <- c(
528	40x	list(family = "lognormal", link = link),
529	40x	stats::make.link(link)
530		)
531	40x	class(family_class) <- "family"
532	40x	return(family_class)
533		}
534
535		#' @rdname lognormal
536		#' @keywords distribution
537		#' @export
538		multinomial <- function(link = "logit") {
539	63x	family_class <- c(
540	63x	list(family = "multinomial", link = link),
541	63x	stats::make.link(link)
542		)
543	63x	class(family_class) <- "family"
544	63x	return(family_class)
545		}

1		# This file contains many functions to reshape output from get_output()
2		# To remove the NOTE `no visible binding for global variable`
3		utils::globalVariables(c(
4		"data", "data_id", "data_ids", "data_type",
5		"delete_me",
6		"density_component",
7		"derived_quantities", "dimensionality",
8		"fleet",
9		"join_by", "json",
10		"input_type",
11		"label", "label_splits", "likelihood", "log_sd_values",
12		"module_name", "module_id", "module_type",
13		"observed_data_id", "observed_values",
14		"parameter_min", "parameter_max",
15		"parameters",
16		"population"
17		))
18
19		#' Reshape JSON estimates
20		#'
21		#' @description
22		#' This function processes the finalized FIMS JSON output and reshapes the
23		#' parameter estimates into a structured tibble for easier analysis and
24		#' manipulation.
25		#'
26		#' @param model_output A JSON object containing the finalized FIMS output as
27		#' returned from `get_output()`, which is an internal function to each model
28		#' family.
29		#' @return A tibble containing the reshaped parameter estimates.
30		reshape_json_estimates <- function(model_output) {
31	30x	json_list <- jsonlite::fromJSON(model_output, simplifyVector = FALSE)
32	30x	read_list <- purrr::map(
33	30x	json_list[!names(json_list) %in% c(
34	30x	"name", "type", "estimation_framework", "id", "objective_function_value",
35	30x	"max_gradient_component", "gradient",
36	30x	"population_ids", "fleet_ids", "log"
37		)],
38	30x	\(x) tidyr::unnest_wider(tibble::tibble(json = x), json)
39		)
40
41		# Process the module parameters
42	30x	module_information <- purrr::map_df(
43	30x	read_list[
44	30x	!names(read_list) %in%
45	30x	c(
46	30x	"name", "type", "estimation_framework", "id",
47	30x	"objective_function_value", "populations", "fleets", "data",
48	30x	"density_components", "population_ids", "fleet_ids"
49		)
50		],
51	30x	.f = \(y) dplyr::mutate(
52	30x	y,
53	30x	parameters = purrr::map(
54	30x	parameters,
55	30x	\(x) purrr::map_df(x, dimension_folded_to_tibble)
56		)
57		)
58		) \|>
59	30x	tidyr::unnest(parameters)
60
61		# Process the fleet-level information
62	30x	fleet_density_data <- read_list[["fleets"]] \|>
63	30x	dplyr::select(module_id, data_ids) \|>
64	30x	dplyr::mutate(
65	30x	data_ids = purrr::map(
66	30x	data_ids,
67	30x	\(y) tibble::enframe(unlist(y), name = "data_type", value = "data_id")
68		)
69		) \|>
70	30x	tidyr::unnest(data_ids) \|>
71	30x	dplyr::filter(data_id != -999) \|>
72	30x	dplyr::mutate(
73	30x	name = paste(data_type, "expected", sep = "_")
74		) \|>
75	30x	dplyr::left_join(
76	30x	y = read_list[["density_components"]] \|>
77	30x	dplyr::filter(
78	30x	observed_data_id != -999
79		) \|>
80	30x	dplyr::rename(distribution = "module_type") \|>
81	30x	dplyr::select(-dplyr::starts_with("module")),
82	30x	by = c("data_id" = "observed_data_id")
83		) \|>
84	30x	dplyr::mutate(
85	30x	density_component = purrr::map(density_component, density_to_tibble)
86		) \|>
87	30x	tidyr::unnest(density_component) \|>
88	30x	dplyr::select(-dplyr::starts_with("data_")) \|>
89	30x	dplyr::group_by(module_id, name) \|>
90	30x	dplyr::mutate(join_by = dplyr::row_number()) \|>
91	30x	dplyr::ungroup()
92
93	30x	fleet_information <- read_list[["fleets"]] \|>
94	30x	tidyr::pivot_longer(
95	30x	cols = c(parameters, derived_quantities),
96	30x	names_to = "delete_me",
97	30x	values_to = "parameters"
98		) \|>
99	30x	dplyr::select(-delete_me, -data_ids) \|>
100		# Remove column ids that are not currently needed
101	30x	dplyr::select(-dplyr::matches("^n.+s$")) \|>
102	30x	dplyr::mutate(
103	30x	parameters = purrr::map(
104	30x	parameters,
105	30x	\(x) purrr::map_df(x, dimension_folded_to_tibble)
106		)
107		) \|>
108	30x	tidyr::unnest(parameters) \|>
109	30x	dplyr::group_by(module_id, name) \|>
110	30x	dplyr::mutate(join_by = dplyr::row_number()) \|>
111	30x	dplyr::ungroup() \|>
112	30x	dplyr::left_join(
113	30x	fleet_density_data,
114	30x	by = c("module_id", "name", "join_by"),
115	30x	suffix = c("", "_density")
116		) \|>
117	30x	dplyr::select(-join_by)
118
119		# Process the data components
120		# TODO: Data component needs actual uncertainty instead of 0
121	30x	data_information <- read_list[["data"]] \|>
122	30x	dplyr::mutate(
123	30x	dimensionality = purrr::map(dimensionality, \(x) dimensions_to_tibble(x))
124		) \|>
125	30x	tidyr::unnest(c(dimensionality, value, uncertainty)) \|>
126	30x	dplyr::mutate(value = unlist(value), uncertainty = unlist(uncertainty))
127
128		# Process the density components
129		# This is done above for fleet information but we will need to do it for
130		# parameter-level information once we have a link to the parameter id
131	30x	density_information <- read_list[["density_components"]] \|>
132	30x	dplyr::mutate(
133	30x	density_component = purrr::map(density_component, density_to_tibble)
134		) \|>
135	30x	tidyr::unnest(density_component)
136
137		# Process the population data
138	30x	population_information <- read_list[["populations"]] \|>
139	30x	tidyr::pivot_longer(
140	30x	cols = c(parameters, derived_quantities),
141	30x	names_to = "delete_me",
142	30x	values_to = "parameters"
143		) \|>
144		# TODO: Think about these ids when we have more than one population
145	30x	dplyr::select(-delete_me, -dplyr::ends_with("_id"), -population) \|>
146	30x	dplyr::mutate(
147	30x	parameters = purrr::map(
148	30x	parameters,
149	30x	\(x) purrr::map_df(x, dimension_folded_to_tibble)
150		)
151		) \|>
152	30x	tidyr::unnest(parameters)
153
154		# TODO: Change some column names
155		# Bring everything together
156	30x	out <- dplyr::bind_rows(
157		# density_information,
158	30x	fleet_information,
159	30x	module_information,
160	30x	population_information
161		) \|>
162	30x	dplyr::select(
163	30x	module_name, module_id, module_type,
164	30x	"label" = name,
165	30x	type, type_id, "parameter_id" = id,
166	30x	fleet, dplyr::ends_with("_i"),
167	30x	"input" = value,
168	30x	estimated = "estimated_value",
169	30x	"expected" = expected_values,
170	30x	"observed" = observed_values,
171	30x	estimation_type,
172	30x	distribution,
173	30x	input_type, lpdf = "lpdf_value", likelihood,
174	30x	"log_sd" = log_sd_values,
175	30x	dplyr::everything()
176		)
177		}
178
179		#' Reshape TMB estimates
180		#'
181		#' @description
182		#' This function processes the TMB std and reshapes them into a structured
183		#' tibble for easier analysis and manipulation.
184		#'
185		#' @param obj An object returned from [TMB::MakeADFun()].
186		#' @param sdreport An object of the `sdreport` class as returned from
187		#' [TMB::sdreport()].
188		#' @param opt An object returned from an optimizer, typically from
189		#' [stats::nlminb()], used to fit a TMB model. If the model is not optimized,
190		#' opt is an empty list and is not used in the function.
191		#' @param parameter_names A character vector of parameter names. This is used to
192		#' identify the parameters in the `std` object.
193		#' @return A tibble containing the reshaped estimates (i.e., parameters and
194		#' derived quantities).
195		reshape_tmb_estimates <- function(obj,
196		sdreport = NULL,
197		opt = NULL,
198		parameter_names) {
199		# Outline for the estimates table
200	29x	estimates_outline <- tibble::tibble(
201		# The FIMS Rcpp module
202	29x	module_name = character(),
203		# The unique ID of the module
204	29x	module_id = integer(),
205		# The name of the parameter or derived quantity
206	29x	label = character(),
207		# The unique ID of the parameter
208	29x	parameter_id = integer(),
209		# The initial value use to start the optimization procedure
210	29x	initial = numeric(),
211		# The estimated parameter value, which would be the MLE estimate or the value
212		# used for a given MCMC iteration
213	29x	estimate = numeric(),
214		# Estimated uncertainty, reported as a standard deviation
215	29x	uncertainty = numeric(),
216		# The pointwise log-likelihood used for the test or holdout data
217	29x	log_like_cv = numeric(),
218		# The gradient component for that parameter, NA for derived quantities
219	29x	gradient = numeric()
220		)
221
222	29x	if (length(sdreport) > 0) {
223	23x	std <- summary(sdreport)
224		# Number of rows for derived quantities: based on the difference
225		# between the total number of rows in std and the length of parameter_names.
226	23x	derived_quantity_nrow <- nrow(std) - length(parameter_names)
227		# Create a tibble with the data from the std, and then apply transformations.
228	23x	estimates <- estimates_outline \|>
229	23x	tibble::add_row(
230	23x	label = dimnames(std)[[1]],
231	23x	estimate = std[, "Estimate"],
232	23x	uncertainty = std[, "Std. Error"],
233		# Use obj[["env"]][["parameters"]][["p"]] as this will return both initial
234		# fixed and random effects while obj[["par"]] only returns initial fixed
235		# effects
236	23x	initial = c(
237	23x	obj[["env"]][["parameters"]][["p"]],
238	23x	rep(NA_real_, derived_quantity_nrow)
239		),
240	23x	gradient = c(
241	23x	obj[["gr"]](opt[["par"]]),
242	23x	rep(NA_real_, derived_quantity_nrow)
243		)
244		)
245		} else {
246	6x	estimates <- estimates_outline \|>
247	6x	tibble::add_row(
248	6x	label = names(obj[["par"]]),
249	6x	initial = obj[["env"]][["parameters"]][["p"]],
250	6x	estimate = obj[["env"]][["parameters"]][["p"]]
251		)
252		}
253
254	29x	estimates <- estimates \|>
255		# Split labels and extract module, id, label, and parameter id
256	29x	dplyr::mutate(label_splits = strsplit(label, split = "\\.")) \|>
257	29x	dplyr::rowwise() \|>
258		# TODO: the code could be simplified using tidyr::separate_wider_*().
259		# However, doing so would require avoiding pre-specification of these columns
260		# in the estimates_outline tibble. Consider updating the code if we decide
261		# not to create the `estimates_outline` tibble in advance.
262	29x	dplyr::mutate(
263	29x	module_name = ifelse(length(label_splits) > 1, label_splits[[1]], NA_character_),
264	29x	module_id = ifelse(length(label_splits) > 1, as.integer(label_splits[[2]]), NA_integer_),
265	29x	label = ifelse(length(label_splits) > 1, label_splits[[3]], label),
266	29x	parameter_id = ifelse(length(label_splits) > 1, as.integer(label_splits[[4]]), NA_integer_)
267		) \|>
268	29x	dplyr::select(-label_splits) \|>
269	29x	dplyr::ungroup()
270		}
271
272		#' Converts a dimension-folder section into a tibble
273		#'
274		#' This is an internal helper function that processes a complex list
275		#' structure read in from a json file containing dimensionality information, a
276		#' name, and either explicit values with a type or estimated values with
277		#' uncertainty.
278		#'
279		#' @param section A section of the json file represented as a list.
280		#' @return
281		#' A tibble containing the json output in a formatted structure listing the
282		#' dimensionality as columns rather than just row and column lengths.
283		#' @noRd
284		#'
285		#' @examples
286		#' # A simple example for a value with uncertainty:
287		#' section_derived <- list(
288		#' name = "derived_quantity_name",
289		#' dimensionality = list(
290		#' unit = "m", symbol = "L", scale = 1.0, type = "length"
291		#' ),
292		#' value = 10.5,
293		#' uncertainty = 0.5
294		#' )
295		#' dimension_folded_to_tibble(section_derived)
296		dimension_folded_to_tibble <- function(section) {
297	2100x	if (length(section) == 0) {
298	!	return(NA)
299		}
300	2100x	while (length(section) == 1) {
301	!	section <- unlist(section, recursive = FALSE)
302		}
303	2100x	temp <- dimensions_to_tibble(section[["dimensionality"]]) \|>
304	2100x	dplyr::mutate(name = section[["name"]])
305	2100x	if ("type" %in% names(section)) {
306	540x	temp \|>
307	540x	dplyr::mutate(
308		# TODO: Need to rename
309	540x	type_id = section[["id"]],
310	540x	type = section[["type"]]
311		) \|>
312	540x	dplyr::bind_cols(
313	540x	tibble::tibble(data = section[["values"]]) \|>
314	540x	tidyr::unnest_wider(data)
315		)
316		} else {
317	1560x	temp \|>
318	1560x	dplyr::bind_cols(
319	1560x	estimated_value = unlist(section[["value"]]),
320	1560x	estimation_type = "derived_quantity"
321		)
322		}
323		}
324
325		#' Covert the dimension information from a FIMS json output into a tibble
326		#'
327		#' Dimensions in the json output are stored as a list of length two, with the
328		#' header information containing the name of the dimension and the dimensions
329		#' containing integers specifying the length for each dimension. The result
330		#' helps interpret how the FIMS output is structured given it is dimension
331		#' folded into a single vector in the json output.
332		#'
333		#' @details
334		#' The dimension index is returned not the actual year of the model. For
335		#' example, if the model starts in year 1900, then year_i of 1, which is what
336		#' is returned from this function will need to map to 1900 and that will need
337		#' to be done externally.
338		#' This function will accommodate dimensions of year-1 and year+1 where the
339		#' indexing of the former will start at 2 instead of 1.
340		#' @param data A list containing the header and dimensions information from a
341		#' FIMS json output object.
342		#' @return
343		#' A tibble containing ordered rows for each combination of the dimensions.
344		#' @noRd
345		#' @examples
346		#' dummy_dimensions <- list(
347		#' header = list("n_years", "n_ages"),
348		#' dimensions = list(30L, 12L)
349		#' )
350		#' dimensions_to_tibble(dummy_dimensions)
351		#' # Example with n_years+1
352		#' dummy_dimensions <- list(
353		#' header = list("n_years+1", "n_ages"),
354		#' dimensions = list(31L, 12L)
355		#' )
356		#' dimensions_to_tibble(dummy_dimensions)
357		dimensions_to_tibble <- function(data) {
358		#' Replace headers like "n_years" with "year_i".
359		#' Example: "n_ages+1" with "age_i"
360		#' This matches names starting with 'n' (with or without an underscore)
361		#' and shortens them to a simple indexed form.
362	2242x	better_names <- unlist(data[["header"]]) \|>
363	2242x	gsub(pattern = "^n_?(.+?)s([-\\+]\\d+)?$", replacement = "\\1_i")
364	2242x	names(data[["dimensions"]]) <- better_names
365	2242x	if (length(better_names) == 0) {
366		# When the header is NULL
367	240x	return(tibble::add_row(tibble::tibble()))
368		}
369	2002x	if ("na" %in% better_names && length(better_names) == 1) {
370		# When the dimensions are na because there is no associated indexing
371	60x	return(tibble::add_row(tibble::tibble()))
372		}
373		# Accommodate any -1 by creating a different start value
374	1942x	test <- grepl("-\\d", data[["header"]])
375	1942x	addition <- gsub(".+-(\\d)", "\\1", data[["header"]])
376	1942x	addition[!test] <- 0
377	1942x	start <- 1 + as.numeric(addition)
378	1942x	data[["dimensions"]][test] <- as.numeric(data[["dimensions"]][test]) +
379	1942x	as.numeric(addition)
380		# Create the returned tibble by first sequencing from 1:n for each dimension
381	1942x	purrr::map2(start, data[["dimensions"]], seq) \|>
382	1942x	purrr::set_names(names(data[["dimensions"]])) \|>
383	1942x	expand.grid() \|>
384	1942x	tibble::as_tibble() \|>
385	1942x	dplyr::arrange(!!!rlang::syms(better_names))
386		}
387
388		#' Convert the density component information into a tibble
389		#'
390		#' @description
391		#' The log probability density function (lpdf) information is information in
392		#' the json that pertains to a distribution, which is often associated with a
393		#' data stream. For example, the lognormal distribution can be associated with
394		#' landings for a given fleet because those landings might be uncertain.
395		#'
396		#' @details
397		#' The raw information, i.e., `data` is a list of unknown dimensions, where the
398		#' first element of the list, i.e., `lpdf_value`, is a single numeric value and
399		#' the remaining list elements are lists themselves. This function converts the
400		#' list to a tibble and then extracts only columns that have some derivative of
401		#' "value" in their name, e.g., `lpdf_value`, `expected_values`, etc., using
402		#' regular expression matching. Thus, when `data` does not have an entry for
403		#' `log_sd_values` the function does not fail but will return a smaller tibble
404		#' than normal.
405		#'
406		#' It is imperative that each list element of `data` be of length one or the
407		#' exact same length as the other elements. There is an internal check in the
408		#' function for this consistency.
409		#'
410		#' The code that writes this json information is stored in `inst/include/interface/rcpp/rcpp_objects/rcpp_distribution.hpp`.
411		#' @param data A list of `density_components` from the json output that is a
412		#' list of lists. The first element of the list will be `lpdf_value`, a
413		#' single entry that stores the log probability density function value. The
414		#' remaining list elements have "value" in their name and are formatted as
415		#' lists themselves.
416		#' @return
417		#' A tibble is returned with the `lpdf_value` first and then other columns with
418		#' value in their name following. The columns will be in the same order they
419		#' are reported in the json output.
420		#' @noRd
421		#'
422		#' @examples
423		#' dummy_density <- list(
424		#' name = "lpdf_vec",
425		#' lpdf_value = -102.079,
426		#' values = list(
427		#' -1.39915, -2.44735, -2.93024, -3.21848, -2.95698, -3.51745
428		#' ),
429		#' expected_values = list(
430		#' 5.0854, 6.13354, 6.61636, 6.90467, 6.64311, 7.20302
431		#' ),
432		#' observed_values = list(
433		#' 161.646, 461.089, 747.29, 996.971, 767.548, 1343.86
434		#' )
435		#' )
436		#' density_to_tibble(dummy_density)
437		#' @noRd
438		density_to_tibble <- function(data) {
439		# Check that each list element is of length-one or the same length otherwise
440		# the resulting tibble will not be the correct dimensions
441	314x	element_lengths <- purrr::map_int(data, length)
442	314x	check <- if (all(element_lengths == 1)) {
443	!	TRUE
444		} else {
445	314x	length(unique(element_lengths[element_lengths != 1])) == 1
446		}
447	314x	if (!check) {
448	!	cli::cli_abort(
449	!	"Not all elements in the density component information are equal or of
450	!	length 1, their lengths are as follows: {element_lengths}.
451	!	The lpdf_value of this element is {data[['lpdf_value']][1]}."
452		)
453		}
454
455		# Return the tibble
456	314x	data \|>
457	314x	tibble::as_tibble() \|>
458	314x	tidyr::unnest(dplyr::contains("value")) \|>
459	314x	dplyr::rename(likelihood = value)
460		}

1		# To remove the WARNING
2		# no visible binding for global variable
3		utils::globalVariables(c(
4		"everything", "fleet_name"
5		))
6
7		#' Create a default FIMS configuration tibble
8		#'
9		#' @description
10		#' This function generates a default configuration tibble for a Fisheries
11		#' Integrated Modeling System (FIMS) model based on the data input. It
12		#' automatically creates configuration entries for data modules (e.g., landings,
13		#' index, compositions) and, depending on the model family, standard population
14		#' dynamics modules (recruitment, growth, maturity) and selectivity modules for
15		#' fleets.
16		#'
17		#' @details
18		#' The function inspects the data to find unique combinations of fleet
19		#' names and data types. It then maps these to the appropriate FIMS module names
20		#' and joins them with a predefined template of default settings. When the
21		#' `model_family` is "catch_at_age", it also adds default configurations for:
22		#' \itemize{
23		#' \item Selectivity: A logistic selectivity module for each unique fleet.
24		#' \item Recruitment: A Beverton--Holt recruitment module.
25		#' \item Growth: An empirical weight-at-age (EWAA) growth module.
26		#' \item Maturity: A logistic maturity module.
27		#' }
28		#' The final output is a nested tibble, which serves as a starting point for
29		#' building a complete FIMS model configuration.
30		#'
31		#' @param data An S4 object of class `FIMSFrame`. FIMS input data.
32		#' @param model_family A string specifying the model family.
33		#' Defaults to `"catch_at_age"`.
34		#'
35		#' @return A `tibble` with default model configurations. The tibble has a nested
36		#' structure with the following top-level columns.
37		#' \describe{
38		#' \item{\code{model_family}:}{The specified model family (e.g.,
39		#' "catch_at_age").}
40		#' \item{\code{module_name}:}{The name of the FIMS module (e.g.,
41		#' "Data", "Selectivity", "Recruitment", "Growth", "Maturity").}
42		#' \item{\code{fleet_name}:}{The name of the fleet the module applies to. This
43		#' will be `NA` for non-fleet-specific modules like "Recruitment".}
44		#' \item{\code{data}:}{A list-column containing a `tibble` with detailed
45		#' configurations. Unnesting this column reveals:
46		#' \describe{
47		#' \item{\code{module_type}:}{The specific type of the module (e.g.,
48		#' "Logistic" for a "Selectivity" module).}
49		#' \item{\code{distribution_link}:}{The component the distribution module
50		#' links to.}
51		#' \item{\code{distribution_type}:}{The type of distribution (e.g., "Data",
52		#' "process").}
53		#' \item{\code{distribution}:}{The name of distribution (e.g.,
54		#' "Dlnorm", `Dmultinom`).}
55		#' }
56		#' }
57		#' }
58		#'
59		#' @export
60		#'
61		#' @examples
62		#' # Load the example dataset and create a FIMS data frame
63		#' data("data_big")
64		#' fims_frame <- FIMSFrame(data_big)
65		#'
66		#' # Create the default model configuration tibble
67		#' default_configurations <- create_default_configurations(data = fims_frame)
68		#'
69		#' # Unnest the data column to see detailed configurations
70		#' default_configurations_unnest <- default_configurations \|>
71		#' tidyr::unnest(cols = data) \|>
72		#' print()
73		#'
74		#' # Model fleet1 with double logistic selectivity
75		#' configurations_double_logistic <- default_configurations_unnest \|>
76		#' dplyr::rows_update(
77		#' tibble::tibble(
78		#' module_name = "Selectivity",
79		#' fleet_name = "fleet1",
80		#' module_type = "DoubleLogistic"
81		#' ),
82		#' by = c("module_name", "fleet_name")
83		#' ) \|>
84		#' print()
85		create_default_configurations <- function(data, model_family = c("catch_at_age")) {
86		# Check if the input object is a FIMSFrame, aborting if not.
87	13x	if (!inherits(data, "FIMSFrame")) {
88	1x	cli::cli_abort(
89	1x	c(
90	1x	"{.var data} must be a {.cls FIMSFrame} object.",
91	1x	"i" = "Please convert your data before using this function."
92		)
93		)
94		}
95
96		# Ensures the user input matches the options provided,
97		# if not, then match.arg() throws an error
98	12x	model_family <- match.arg(model_family)
99
100		# Extract unique combinations of fleet names and data types from the data.
101		# This forms the basis for determining which modules are needed for each fleet.
102	11x	unique_fleet_types <- data \|>
103	11x	get_data() \|>
104	11x	dplyr::distinct(name, type) \|>
105		# Convert type from snake_case to PascalCase
106	11x	dplyr::mutate(module_type = snake_to_pascal(type)) \|>
107		# Set module_type to NA for weight-at-age and age-to-length-conversion
108	11x	dplyr::mutate(module_type = dplyr::case_when(
109	11x	type == "weight_at_age" ~ NA_character_,
110	11x	type == "age_to_length_conversion" ~ NA_character_,
111	11x	TRUE ~ module_type
112		)) \|>
113		# Remove any combinations where the type did not match a known module.
114	11x	dplyr::filter(!is.na(module_type)) \|>
115	11x	dplyr::rename(fleet_name = name) \|>
116	11x	dplyr::select(-type)
117
118		# Define a template for data modules (comps, landings, index).
119		# This specifies the default distribution for each type of data.
120	11x	data_config_template <- dplyr::tribble(
121	11x	~module_name, ~module_type, ~distribution_link, ~distribution_type, ~distribution,
122	11x	"Data", "Landings", "Landings", "Data", "Dlnorm",
123	11x	"Data", "Index", "Index", "Data", "Dlnorm",
124	11x	"Data", "AgeComp", "AgeComp", "Data", "Dmultinom",
125	11x	"Data", "LengthComp", "LengthComp", "Data", "Dmultinom"
126		)
127
128		# Create data module configurations by joining the unique fleet types
129		# with the corresponding template entries.
130	11x	fleet_data_config <- unique_fleet_types \|>
131	11x	dplyr::left_join(data_config_template, by = "module_type")
132
133		# Initialize placeholders for conditional configurations.
134	11x	selectivity_config <- tibble::tibble()
135	11x	other_config <- tibble::tibble()
136
137		# If model_family is "catch_at_age", create selectivity configurations for
138		# fleets and other configurations for population dynamics.
139	11x	if (model_family == "catch_at_age") {
140		# Create these rows by getting distinct fleet names and joining them
141		# with the selectivity template.
142	11x	selectivity_config <- unique_fleet_types \|>
143	11x	dplyr::distinct(fleet_name) \|>
144	11x	dplyr::mutate(
145	11x	module_name = "Selectivity",
146	11x	module_type = "Logistic"
147		)
148
149		# Define a template for standard, non-fleet-specific modules.
150	11x	other_config <- dplyr::tribble(
151	11x	~module_name, ~module_type, ~distribution_link, ~distribution_type, ~distribution,
152	11x	"Recruitment", "BevertonHolt", "log_devs", "process", "Dnorm",
153	11x	"Growth", "EWAA", NA_character_, NA_character_, NA_character_,
154	11x	"Maturity", "Logistic", NA_character_, NA_character_, NA_character_
155		)
156		}
157
158		# Combine all configuration pieces into a single tibble.
159		# The `dplyr::bind_rows` function intelligently handles differing columns
160		# by filling missing values with NA.
161	11x	final_config <- dplyr::bind_rows(
162	11x	fleet_data_config,
163	11x	selectivity_config,
164	11x	other_config
165		) \|>
166		# Add model_family column
167	11x	dplyr::mutate(model_family = model_family) \|>
168		# Arrange for readability.
169	11x	dplyr::arrange(fleet_name, module_name) \|>
170		# Reorder columns
171	11x	dplyr::select(
172	11x	model_family, module_name, module_type, fleet_name, everything()
173		) \|>
174		# Nest the configuration details into a list-column called 'data'.
175		# This creates the final, structured output format expected by FIMS.
176	11x	tidyr::nest(.by = c(model_family, module_name, fleet_name))
177		}
178
179		#' Convert snake_case strings to PascalCase
180		#'
181		#' This function takes a vector of strings in snake_case format and converts
182		#' them to PascalCase.
183		#'
184		#' @param snake_strings A vector of strings in snake_case format.
185		#' @return A vector of strings in PascalCase format.
186		#' @examples
187		#' snake_to_pascal(c("age_comp", "length_comp"))
188		#' snake_to_pascal("index")
189		#' @noRd
190		snake_to_pascal <- function(snake_strings) {
191	11x	purrr::map_chr(snake_strings, \(x) {
192	83x	parts <- strsplit(x, "_")[[1]]
193	83x	paste(
194	83x	toupper(substring(parts, 1, 1)),
195	83x	substring(parts, 2),
196	83x	sep = "",
197	83x	collapse = ""
198		)
199		})
200		}

1		#' Should FIMS be verbose?
2		#'
3		#' Verbosity is set globally for FIMS using
4		#' `options(rlib_message_verbosity = "quiet")` to stop the printing of messages
5		#' from `cli::cli_inform()`. Using a global option allows for verbose to not
6		#' have to be an argument to every function. All `cli::cli_abort()` messages are
7		#' printed to the console no matter what the global option is set to.
8		#'
9		#' @return
10		#' A logical is returned where `TRUE` ensures messages from `cli::cli_inform()`
11		#' are printed to the console.
12		#'
13		#' @examples
14		#' # function is not exported
15		#' \dontrun{
16		#' FIMS:::is_fims_verbose()
17		#' }
18		is_fims_verbose <- function() {
19	11x	verbose_option <- getOption("rlib_message_verbosity", default = "default")
20	11x	verbose_boolean <- verbose_option %in% c("default", "verbose")
21	11x	return(verbose_boolean)
22		}

1		/**
2		* @file data_object.hpp
3		* @brief Sets up a data class to create a generic data object with up to five
4		* dimensions. The class contains internal vector for data elements and
5		* uncertainty values.
6		* @copyright This file is part of the NOAA, National Marine Fisheries Service
7		* Fisheries Integrated Modeling System project. See LICENSE in the source
8		* folder for reuse information.
9		*/
10		#ifndef FIMS_COMMON_DATA_OBJECT_HPP
11		#define FIMS_COMMON_DATA_OBJECT_HPP
12
13		#include <exception>
14		#include <vector>
15
16		#include "model_object.hpp"
17		#include "fims_vector.hpp"
18
19		namespace fims_data_object {
20
21		/**
22		* Container to hold user supplied data.
23		*/
24		template <typename Type>
25		struct DataObject : public fims_model_object::FIMSObject<Type> {
26		static uint32_t id_g; /*< id of the Data Object >/
27		fims::Vector<Type> data; /*< vector of the data >/
28		fims::Vector<Type> uncertainty; /*< vector of the data >/
29		size_t dimensions; /*< dimension of the Data object >/
30		size_t imax; /*< 1st dimension of data object >/
31		size_t jmax; /*< 2nd dimension of data object>/
32		size_t kmax; /*< 3rd dimension of data object>/
33		size_t lmax; /*< 4th dimension of data object>/
34		Type na_value = static_cast<Type>(-999); /*< specifying the NA value >/
35
36		/**
37		* Constructs a one-dimensional data object.
38		*/
39	248x	DataObject(size_t imax) : dimensions(1), imax(imax) {
40	248x	data.resize(imax);
41	248x	uncertainty.resize(imax);
42	248x	this->id = DataObject<Type>::id_g++;
43		}
44
45		/**
46		* Constructs a two-dimensional data object.
47		*/
48	440x	DataObject(size_t imax, size_t jmax) : dimensions(2), imax(imax), jmax(jmax) {
49	440x	data.resize(imax * jmax);
50	440x	uncertainty.resize(imax * jmax);
51	440x	this->id = DataObject<Type>::id_g++;
52		}
53
54		/**
55		* Constructs a three-dimensional data object.
56		*/
57		DataObject(size_t imax, size_t jmax, size_t kmax)
58		: dimensions(3), imax(imax), jmax(jmax), kmax(kmax) {
59		data.resize(imax * jmax * kmax);
60		uncertainty.resize(imax * jmax * kmax);
61		this->id = DataObject<Type>::id_g++;
62		}
63
64		/**
65		* Constructs a four-dimensional data object.
66		*/
67		DataObject(size_t imax, size_t jmax, size_t kmax, size_t lmax)
68		: dimensions(4), imax(imax), jmax(jmax), kmax(kmax), lmax(lmax) {
69		data.resize(imax * jmax * kmax * lmax);
70		uncertainty.resize(imax * jmax * kmax * lmax);
71		this->id = DataObject<Type>::id_g++;
72		}
73
74		/**
75		* Retrieve element from 1d data set.
76		* @param i dimension of 1d data set
77		* @return the value of the vector at position i
78		*/
79		inline Type operator()(size_t i) { return data[i]; }
80
81		/**
82		* Retrieve element from 1d data set.
83		* Throws an exception if index is out of bounds.
84		* @param i dimension of 1d data set
85		* @return the reference to the value of the vector at position i
86		*/
87	1995838x	inline Type& at(size_t i) {
88	1995838x	if (i >= this->data.size()) {
89	!	throw std::overflow_error("DataObject error:i index out of bounds");
90		}
91	1995838x	return data[i];
92		}
93
94		/**
95		* Retrieve element from 2d data set.
96		* @param i 1st dimension of 2d data set
97		* @param j 2nd dimension of 2d data set
98		* @return the value of the matrix at position i, j
99		*/
100		inline const Type operator()(size_t i, size_t j) {
101		return data[i * jmax + j];
102		}
103
104		/**
105		* Retrieve element from 2d data set.
106		* Throws an exception if index is out of bounds.
107		* @param i 1st dimension of 2d data set
108		* @param j 2nd dimension of 2d data set
109		* @return the reference to the value of the matrix at position i, j
110		*/
111	2172498x	inline Type& at(size_t i, size_t j) {
112	2172498x	if ((i * jmax + j) >= this->data.size()) {
113	!	throw std::overflow_error("DataObject error: index out of bounds");
114		}
115	2172498x	return data[i * jmax + j];
116		}
117
118		/**
119		* Retrieve element from 3d data set.
120		* @param i 1st dimension of 3d data set
121		* @param j 2nd dimension of 3d data set
122		* @param k 3rd dimension of 3d data set
123		* @return the value of the array at position i, j, k
124		*/
125		inline const Type operator()(size_t i, size_t j, size_t k) {
126		return data[i * jmax * kmax + j * kmax + k];
127		}
128
129		/**
130		* Retrieve element from 3d data set.
131		* Throws an exception if index is out of bounds.
132		* @param i 1st dimension of 3d data set
133		* @param j 2nd dimension of 3d data set
134		* @param k 3rd dimension of 3d data set
135		* @return the reference to the value of the array at position i, j, k
136		*/
137		inline Type& at(size_t i, size_t j, size_t k) {
138		if ((i * jmax * kmax + j * kmax + k) >= this->data.size()) {
139		throw std::overflow_error("DataObject error: index out of bounds");
140		}
141		return data[i * jmax * kmax + j * kmax + k];
142		}
143
144		/**
145		* Retrieve element from 4d data set.
146		* @param i 1st dimension of 4d data set
147		* @param j 2nd dimension of 4d data set
148		* @param k 3rd dimension of 4d data set
149		* @param l 4th dimension of 4d data set
150		* @return the value of the array at position i, j, k, l
151		*/
152		inline const Type operator()(size_t i, size_t j, size_t k, size_t l) {
153		return data[i * jmax * kmax * lmax + j * kmax * lmax + k * lmax + l];
154		}
155
156		/**
157		* Retrieve element from 3d data set.
158		* Throws an exception if index is out of bounds.
159		* @param i 1st dimension of 4d data set
160		* @param j 2nd dimension of 4d data set
161		* @param k 3rd dimension of 4d data set
162		* @param l 4th dimension of 4d data set
163		* @return the reference to the value of the array at position i, j, k, l
164		*/
165		inline Type& at(size_t i, size_t j, size_t k, size_t l) {
166		if ((i * jmax * kmax * lmax + j * kmax * lmax + k * lmax + l) >=
167		this->data.size()) {
168		throw std::overflow_error("DataObject error: index out of bounds");
169		}
170		return data[i * jmax * kmax * lmax + j * kmax * lmax + k * lmax + l];
171		}
172
173		/**
174		* @brief Get the dimensions object
175		*
176		* @return size_t
177		*/
178		size_t get_dimensions() const { return dimensions; }
179
180		/**
181		* @brief Get the imax object
182		*
183		* @return size_t
184		*/
185	344x	size_t get_imax() const { return imax; }
186
187		/**
188		* @brief Get the jmax object
189		*
190		* @return size_t
191		*/
192	344x	size_t get_jmax() const { return jmax; }
193
194		/**
195		* @brief Get the kmax object
196		*
197		* @return size_t
198		*/
199		size_t get_kmax() const { return kmax; }
200
201		/**
202		* @brief Get the lmax object
203		*
204		* @return size_t
205		*/
206		size_t get_lmax() const { return lmax; }
207		};
208
209		template <typename Type>
210		uint32_t DataObject<Type>::id_g = 0;
211
212		} // namespace fims_data_object
213
214		#endif

1		/**
2		* @file def.hpp
3		* @brief Creates pre-processing macros such as what type of machine you are on
4		* and creates the log information.
5		* @copyright This file is part of the NOAA, National Marine Fisheries Service
6		* Fisheries Integrated Modeling System project. See LICENSE in the source
7		* folder for reuse information.
8		*/
9		#ifndef DEF_HPP
10		#define DEF_HPP
11		#include <fstream>
12		#include <map>
13		#include <memory>
14		#include <vector>
15		#include <string>
16		#include <unordered_map>
17
18		#include <cstdlib>
19		#include <chrono>
20		#include <sstream>
21		#include <iostream>
22		#include <filesystem>
23		#include <stdlib.h>
24		#include <fstream>
25		#include <signal.h>
26		#include <csignal>
27		#include <cstring>
28
29		#include <stdexcept>
30
31		#if defined(linux) \|\| defined(__linux) \|\| defined(__linux__)
32		#define FIMS_LINUX
33		#elif defined(__FreeBSD__) \|\| defined(__NetBSD__) \|\| defined(__OpenBSD__) \|\| \
34		defined(__DragonFly__)
35		#define FIMS_BSD
36		#elif defined(sun) \|\| defined(__sun)
37		#define FIMS_SOLARIS
38		#elif defined(__sgi)
39		#define FIMS_IRIX
40		#elif defined(__hpux)
41		#define FIMS_HPUX
42		#elif defined(__CYGWIN__)
43		#define FIMS_CYGWIN
44		#elif defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(WIN32)
45		#define FIMS_WIN32
46		#elif defined(_WIN64) \|\| defined(__WIN64__) \|\| defined(WIN64)
47		#define FIMS_WIN64
48		#elif defined(__BEOS__)
49		#define FIMS_BEOS
50		#elif defined(macintosh) \|\| defined(__APPLE__) \|\| defined(__APPLE_CC__)
51		#define FIMS_MACOS
52		#elif defined(__IBMCPP__) \|\| defined(_AIX)
53		#define FIMS_AIX
54		#elif defined(__amigaos__)
55		#define FIMS_AMIGAOS
56		#elif defined(__QNXNTO__)
57		#define FIMS_QNXNTO
58		#endif
59
60		#if defined(FIMS_WIN32) \|\| defined(FIMS_WIN64)
61		#define FIMS_WINDOWS
62		#endif
63
64		#ifdef FIMS_WINDOWS
65		#include <Windows.h>
66		#include <Lmcons.h> // for UNLEN
67		#elif defined(FIMS_LINUX) \|\| defined(FIMS_MACOS) \|\| defined(FIMS_BSD)
68		#include <unistd.h>
69		#include <pwd.h>
70		#endif
71
72		#if !defined(__PRETTY_FUNCTION__) && !defined(__GNUC__)
73		#ifdef FIMS_WINDOWS
74		#define __PRETTY_FUNCTION__ __FUNCTION__
75		#endif
76		#endif
77
78		// The following rows initialize default log files for outputting model progress
79		// comments used to assist in diagnosing model issues and tracking progress.
80		// These files will only be created if a logs folder is added to the root model
81		// directory.
82
83		#ifdef TMB_MODEL
84		// simplify access to singletons
85		#define TMB_FIMS_REAL_TYPE double
86		#define TMBAD_FIMS_TYPE TMBad::ad_aug
87		#endif
88
89		namespace fims {
90
91		/**
92		* Log entry.
93		*/
94		struct LogEntry {
95		/** The date/time that the log entry was created, e.g., "Oct 28 09:18:51
96		* 2024". You can track how long it took to work through each portion of the
97		* model by analyzing the progression of the timestamp through the log file.*/
98		std::string timestamp;
99		/** The description of the log entry, e.g., "Adding Selectivity object to TMB"
100		* or "Mismatch dimension error", where the descriptions are predefined in the
101		* C++ code. Please make a GitHub issue or contact a developer if you have
102		* ideas for a more informative description.*/
103		std::string message;
104		/** The logging level, which is a result of which macro was used to generate
105		* the message, e.g., FIMS_INFO_LOG(), FIMS_WARNING_LOG(), or FIMS_ERROR_LOG()
106		* results in "info", "warning", or "error", respectively, in the log file.*/
107		std::string level;
108		/** The message id, directly corresponds to the order in which the entries
109		* were created, e.g., "1", which is helpful for knowing the order of
110		* operations within the code base and comparing log files across model
111		* runs.*/
112		size_t rank;
113		/** The user name registered to the computer where the log file was created,
114		* e.g., "John.Doe".*/
115		std::string user;
116		/** The working directory for the R environment that created the log file,
117		* e.g., "C:/github/NOAA-FIMS/FIMS/vignettes" if you are on a Windows machine
118		* or "/home/oppy/FIMS-Testing/dev/dev_logging/FIMS/vignettes" if you are on a
119		* linux machine.*/
120		std::string wd;
121		/** The full file path of the file that triggered the log entry, e.g.,
122		* "C:/github/NOAA-FIMS/FIMS/inst/include/interface/rcpp/rcpp_objects/rcpp_selectivity.hpp".*/
123		std::string file;
124		/** The function or method that led to the initialization the log entry, e.g.,
125		* "virtual bool LogisticSelectivityInterface::add_to_fims_tmb()". If the
126		* function is templated, then the function type will be reported here in
127		* square brackets after the function name, e.g., "bool
128		* fims_info::Information<Type>::CreateModel() [with Type = double]".*/
129		std::string routine;
130		/** The line in `file` where the log entry was initiated, e.g., "219", which
131		* will be a line inside of the `routine` listed above.*/
132		int line;
133
134		/**
135		* Convert this object to a string.
136		*/
137	24189x	std::string to_string() {
138	24189x	std::stringstream ss;
139	24189x	ss << "\"timestamp\": " << "\"" << this->timestamp << "\"" << ",\n";
140	24189x	ss << "\"level\": " << "\"" << this->level << "\",\n";
141	24189x	ss << "\"message\": " << "\"" << this->message << "\",\n";
142	24189x	ss << "\"id\": " << "\"" << this->rank << "\",\n";
143	24189x	ss << "\"user\": " << "\"" << this->user << "\",\n";
144	24189x	ss << "\"wd\": " << "\"" << this->wd << "\",\n";
145	24189x	ss << "\"file\": " << "\"" << this->file << "\",\n";
146	24189x	ss << "\"routine\": " << "\"" << this->routine << "\",\n";
147	24189x	ss << "\"line\": " << "\"" << this->line << "\"\n";
148	48378x	return ss.str();
149		}
150		};
151
152		/**
153		* FIMS logging class.
154		*/
155		class FIMSLog {
156		std::vector<std::string> entries;
157		std::vector<LogEntry> log_entries;
158		size_t entry_number = 0;
159		std::string path = "fims.log";
160		size_t warning_count = 0;
161		size_t error_count = 0;
162
163		/**
164		* Get username.
165		*
166		* @return username.
167		*/
168	31997x	std::string get_user() {
169		#ifdef FIMS_WINDOWS
170		char username[UNLEN + 1];
171		DWORD username_len = UNLEN + 1;
172		if (GetUserNameA(username, &username_len)) {
173		return std::string(username);
174		} else {
175		return "[unknown user]";
176		}
177
178		#elif defined(FIMS_LINUX) \|\| defined(FIMS_MACOS) \|\| defined(FIMS_BSD)
179	31997x	const char* user_env = getenv("USER");
180	95991x	if (user_env) return std::string(user_env);
181
182	!	uid_t uid = getuid();
183	!	struct passwd* pw = getpwuid(uid);
184	!	if (pw && pw->pw_name) {
185	!	return std::string(pw->pw_name);
186		} else {
187	!	return "[unknown user]";
188		}
189
190		#else
191		return "[unsupported platform]";
192		#endif
193		}
194
195		public:
196		/**
197		* @brief A boolean specifying if the log file is written when the session is
198		* terminated. The default is TRUE.
199		*
200		*/
201		bool write_on_exit = true;
202		/**
203		* @brief A boolean specifying if the program is stopped upon the first
204		* error, where the default is FALSE. This allows you go through an entire
205		* program to collect all error messages.
206		*
207		*/
208		bool throw_on_error = false;
209		/**
210		* @brief A singleton instance of the log, i.e., where there is only one
211		* log. The object is created when the .dll is loaded and it will never
212		* be recreated while the .dll is loaded.
213		*
214		*/
215		static std::shared_ptr<FIMSLog> fims_log;
216
217		/**
218		* Default constructor for FIMSLog.
219		*/
220	9x	FIMSLog() {}
221
222		/**
223		* Destructor. If write_on_exit is set to true,
224		* the log will be written to the disk in JSON format.
225		*/
226	3x	~FIMSLog() {
227	3x	if (this->write_on_exit) {
228	3x	std::ofstream log(this->path);
229	3x	log << this->get_log();
230	3x	log.close();
231		}
232		}
233
234		/**
235		* @brief Get the Absolute Path Without Dot Dot object
236		*
237		* Dot dot notation is for relative paths, where this function replaces
238		* all dot dots with the actual full path.
239		*
240		* @param relativePath A path in your file system.
241		* @return std::filesystem::path
242		*/
243	31997x	std::filesystem::path getAbsolutePathWithoutDotDot(
244		const std::filesystem::path& relativePath) {
245		std::filesystem::path absolutePath =
246	31997x	std::filesystem::absolute(relativePath);
247
248	31997x	std::filesystem::path result;
249	486727x	for (const auto& part : absolutePath) {
250	454730x	if (part == "..") {
251	38961x	if (!result.empty()) {
252	38961x	result = result.parent_path();
253		}
254		} else {
255	415769x	result /= part;
256		}
257		}
258
259	63994x	return result.generic_string();
260		}
261
262		/**
263		* Set a path for the log file.
264		*
265		* @param path
266		*/
267	!	void set_path(std::string path) { this->path = path; }
268
269		/**
270		* Get the path for the log file.
271		*
272		* @return
273		*/
274	!	std::string get_path() { return this->path; }
275
276		/**
277		* Add a "info" level message to the log.
278		*
279		* @param str
280		* @param line
281		* @param file
282		* @param func
283		*/
284	31924x	void info_message(std::string str, int line, const char* file,
285		const char* func) {
286	31924x	std::filesystem::path relativePath = file;
287		std::filesystem::path absolutePath =
288	31924x	getAbsolutePathWithoutDotDot(relativePath);
289	31924x	std::filesystem::path cwd = std::filesystem::current_path();
290	31924x	std::stringstream ss;
291	31924x	auto now = std::chrono::system_clock::now();
292	31924x	std::time_t now_time = std::chrono::system_clock::to_time_t(now);
293	31924x	std::string ctime_no_newline = strtok(ctime(&now_time), "\n");
294
295	31924x	LogEntry l;
296	31924x	l.timestamp = ctime_no_newline;
297	31924x	l.message = str;
298	31924x	l.level = "info";
299	31924x	l.rank = this->log_entries.size();
300	31924x	l.user = this->get_user();
301	31924x	l.wd = cwd.generic_string();
302	31924x	l.file = absolutePath.string();
303	31924x	l.line = line;
304	31924x	l.routine = func;
305	31924x	this->log_entries.push_back(l);
306		}
307
308		/**
309		* Add a "error" level message to the log.
310		*
311		* @param str
312		* @param line
313		* @param file
314		* @param func
315		*/
316	2x	void error_message(std::string str, int line, const char* file,
317		const char* func) {
318	2x	this->error_count++;
319	2x	std::filesystem::path relativePath = file;
320		std::filesystem::path absolutePath =
321	2x	getAbsolutePathWithoutDotDot(relativePath);
322	2x	std::filesystem::path cwd = std::filesystem::current_path();
323
324	2x	std::stringstream ss;
325	2x	auto now = std::chrono::system_clock::now();
326	2x	std::time_t now_time = std::chrono::system_clock::to_time_t(now);
327	2x	std::string ctime_no_newline = strtok(ctime(&now_time), "\n");
328
329	2x	LogEntry l;
330	2x	l.timestamp = ctime_no_newline;
331	2x	l.message = str;
332	2x	l.level = "error";
333	2x	l.rank = this->log_entries.size();
334	2x	l.user = this->get_user();
335	2x	l.wd = cwd.generic_string();
336	2x	l.file = absolutePath.string();
337	2x	l.line = line;
338	2x	l.routine = func;
339	2x	this->log_entries.push_back(l);
340
341	2x	if (this->throw_on_error) {
342	!	std::stringstream ss;
343	!	ss << "\n\n" << l.to_string() << "\n\n";
344	!	throw std::runtime_error(ss.str().c_str());
345		}
346		}
347
348		/**
349		* Add a "warning" level message to the log.
350		*
351		* @param str
352		* @param line
353		* @param file
354		* @param func
355		*/
356	71x	void warning_message(std::string str, int line, const char* file,
357		const char* func) {
358	71x	this->warning_count++;
359	71x	std::filesystem::path relativePath = file;
360		std::filesystem::path absolutePath =
361	71x	getAbsolutePathWithoutDotDot(relativePath);
362	71x	std::filesystem::path cwd = std::filesystem::current_path();
363
364	71x	std::stringstream ss;
365	71x	auto now = std::chrono::system_clock::now();
366	71x	std::time_t now_time = std::chrono::system_clock::to_time_t(now);
367	71x	std::string ctime_no_newline = strtok(ctime(&now_time), "\n");
368
369	71x	LogEntry l;
370	71x	l.timestamp = ctime_no_newline;
371	71x	l.message = str;
372	71x	l.level = "warning";
373	71x	l.rank = this->log_entries.size();
374	71x	l.user = this->get_user();
375	71x	l.wd = cwd.generic_string();
376	71x	l.file = absolutePath.string();
377	71x	l.line = line;
378	71x	l.routine = func;
379	71x	this->log_entries.push_back(l);
380		}
381
382		/**
383		* Get the log as a string object.
384		*
385		* @return
386		*/
387	3x	std::string get_log() {
388	3x	std::stringstream ss;
389	3x	if (log_entries.size() == 0) {
390	2x	ss << "[\n]";
391		} else {
392	1x	ss << "[\n";
393	84x	for (size_t i = 0; i < log_entries.size() - 1; i++) {
394	83x	ss << "{\n" << this->log_entries[i].to_string() << "},\n";
395		}
396		ss << "{\n"
397	1x	<< this->log_entries[log_entries.size() - 1].to_string() << "}\n]";
398		}
399	6x	return ss.str();
400		}
401
402		/**
403		* Return only error entries from the log.
404		*
405		* @return
406		*/
407	24x	std::string get_errors() {
408	24x	std::stringstream ss;
409	24x	std::vector<LogEntry> errors;
410	24129x	for (size_t i = 0; i < log_entries.size(); i++) {
411	24105x	if (log_entries[i].level == "error") {
412	!	errors.push_back(this->log_entries[i]);
413		}
414		}
415
416	24x	if (errors.size() == 0) {
417	24x	ss << "[\n]";
418		} else {
419	!	ss << "[\n";
420	!	for (size_t i = 0; i < errors.size() - 1; i++) {
421	!	ss << "{\n" << errors[i].to_string() << "},\n";
422		}
423
424	!	ss << "{\n" << errors[errors.size() - 1].to_string() << "}\n]";
425		}
426	48x	return ss.str();
427		}
428
429		/**
430		* Return only warning entries from the log.
431		*
432		* @return
433		*/
434	24x	std::string get_warnings() {
435	24x	std::stringstream ss;
436	24x	std::vector<LogEntry> warnings;
437	24129x	for (size_t i = 0; i < log_entries.size(); i++) {
438	24105x	if (log_entries[i].level == "warning") {
439	59x	warnings.push_back(this->log_entries[i]);
440		}
441		}
442
443	24x	if (warnings.size() == 0) {
444	!	ss << "[\n]";
445		} else {
446	24x	ss << "[\n";
447	59x	for (size_t i = 0; i < warnings.size() - 1; i++) {
448	35x	ss << "{\n" << warnings[i].to_string() << "},\n";
449		}
450
451	24x	ss << "{\n" << warnings[warnings.size() - 1].to_string() << "}\n]";
452		}
453	48x	return ss.str();
454		}
455
456		/**
457		* Return only info entries from the log.
458		*
459		* @return
460		*/
461	24x	std::string get_info() {
462	24x	std::stringstream ss;
463	24x	std::vector<LogEntry> info;
464	24129x	for (size_t i = 0; i < log_entries.size(); i++) {
465	24105x	if (log_entries[i].level == "info") {
466	24046x	info.push_back(this->log_entries[i]);
467		}
468		}
469
470	24x	if (info.size() == 0) {
471	!	ss << "[\n]";
472		} else {
473	24x	ss << "[\n";
474	24046x	for (size_t i = 0; i < info.size() - 1; i++) {
475	24022x	ss << "{\n" << info[i].to_string() << "},\n";
476		}
477
478	24x	ss << "{\n" << info[info.size() - 1].to_string() << "}\n]";
479		}
480	48x	return ss.str();
481		}
482
483		/**
484		* Query the log by module.
485		*
486		* @param module
487		* @return
488		*/
489		std::string get_module(const std::string& module) {
490		std::stringstream ss;
491		std::vector<LogEntry> info;
492		for (size_t i = 0; i < log_entries.size(); i++) {
493		if (log_entries[i].file.find(module) != std::string::npos) {
494		info.push_back(this->log_entries[i]);
495		}
496		}
497
498		if (info.size() == 0) {
499		ss << "[\n]";
500		} else {
501		ss << "[\n";
502		for (size_t i = 0; i < info.size() - 1; i++) {
503		ss << "{\n" << info[i].to_string() << "},\n";
504		}
505
506		ss << "{\n" << info[info.size() - 1].to_string() << "}\n]";
507		}
508		return ss.str();
509		}
510
511		/**
512		* @brief Get the counts of the number of errors
513		*/
514		size_t get_error_count() const { return error_count; }
515
516		/**
517		* @brief Get the counts of the number of warnings
518		*/
519		size_t get_warning_count() const { return warning_count; }
520
521		/**
522		* @brief Clears all pointers/references of a FIMS model.
523		*
524		*/
525	150x	void clear() {
526	150x	this->entries.clear();
527	150x	this->log_entries.clear();
528	150x	this->warning_count = 0;
529	150x	this->entry_number = 0;
530		}
531		};
532
533		std::shared_ptr<FIMSLog> FIMSLog::fims_log = std::make_shared<FIMSLog>();
534
535		} // namespace fims
536
537		#define FIMS_INFO_LOG(MESSAGE) \
538		fims::FIMSLog::fims_log->info_message( \
539		MESSAGE, __LINE__, __FILE__, \
540		__PRETTY_FUNCTION__); /*< Print MESSAGE to info log /
541
542		#define FIMS_WARNING_LOG(MESSAGE) \
543		fims::FIMSLog::fims_log->warning_message( \
544		MESSAGE, __LINE__, __FILE__, \
545		__PRETTY_FUNCTION__); /*< Print MESSAGE to warning log /
546
547		#define FIMS_ERROR_LOG(MESSAGE) \
548		fims::FIMSLog::fims_log->error_message( \
549		MESSAGE, __LINE__, __FILE__, \
550		__PRETTY_FUNCTION__); /*< Print MESSAGE to error log /
551
552		#define FIMS_STR(s) #s /*< String of s /
553
554		namespace fims {
555
556		/**
557		* Signal intercept function. Writes the log to the disk before
558		* a crash occurs.
559		*
560		* @param sig
561		*/
562	!	void WriteAtExit(int sig) {
563	!	std::string signal_error = "NA";
564	!	switch (sig) {
565	!	case SIGSEGV:
566	!	signal_error = "Invalid memory access (segmentation fault)";
567	!	break;
568	!	case SIGINT:
569	!	signal_error = "External interrupt, possibly initiated by the user.";
570	!	break;
571	!	case SIGABRT:
572		signal_error =
573	!	"Abnormal termination condition, possible call to std::abort.";
574	!	break;
575	!	case SIGFPE:
576	!	signal_error = "Erroneous arithmetic operation.";
577	!	break;
578	!	case SIGILL:
579	!	signal_error = "Invalid program image or invalid instruction";
580	!	break;
581	!	case SIGTERM:
582	!	signal_error = "Termination request, sent to the program.";
583	!	break;
584	!	default:
585	!	signal_error = "Unknown signal thrown";
586		}
587
588	!	FIMSLog::fims_log->error_message(signal_error, -999, "?", "?");
589
590	!	if (FIMSLog::fims_log->write_on_exit) {
591	!	std::ofstream log(FIMSLog::fims_log->get_path());
592	!	log << FIMSLog::fims_log->get_log();
593	!	log.close();
594		}
595	!	std::signal(sig, SIG_DFL);
596	!	raise(sig);
597		}
598
599		/**
600		* Converts an object T to a string.
601		*
602		* @param v
603		* @return
604		*/
605		template <typename T>
606	61806x	std::string to_string(T v) {
607	61806x	std::stringstream ss;
608	61806x	ss << v;
609	123612x	return ss.str();
610		}
611
612		} // namespace fims
613
614		#endif /* TRAITS_HPP */

1		/**
2		* @file fims_math.hpp
3		* @brief A collection of mathematical functions used in FIMS.
4		* @copyright This file is part of the NOAA, National Marine Fisheries Service
5		* Fisheries Integrated Modeling System project. See LICENSE in the source
6		* folder for reuse information.
7		*/
8		#ifndef FIMS_MATH_HPP
9		#define FIMS_MATH_HPP
10
11		// note: this is modeling platform specific, must be controlled by
12		// preprocessing macros
13		#include <cmath>
14		#include <random>
15		#include <sstream>
16
17		#include "../interface/interface.hpp"
18		#include "fims_vector.hpp"
19
20		namespace fims_math {
21		#ifdef STD_LIB
22
23		/**
24		* @brief The exponential function.
25		*
26		* @param x value to exponentiate. Please use fims_math::exp<double>(x) if x is
27		* an integer.
28		* @return the exponentiated value
29		*/
30		template <class Type>
31		inline const Type exp(const Type &x) {
32		return std::exp(x);
33		}
34
35		/**
36		* @brief The natural log function (base e)
37		* @param x the value to take the log of. Please use fims_math::log<double>(x)
38		* if x is an integer.
39		* @return
40		*/
41		template <class Type>
42		inline const Type log(const Type &x) {
43		return std::log(x);
44		}
45
46		template <class Type>
47		inline const Type cos(const Type &x) {
48		return std::cos(x);
49		}
50
51		template <class Type>
52		inline const Type sqrt(const Type &x) {
53		return std::sqrt(x);
54		}
55
56		template <class Type>
57		inline const Type pow(const Type &x, const Type &y) {
58		return std::pow(x, y);
59		}
60
61		template <class Type>
62		inline const Type lgamma(const Type &x) {
63		return std::lgamma(x);
64		}
65		#endif
66
67		#ifdef TMB_MODEL
68
69		// Add the following line to CMakeLists.txt to enable documentation of TMB_MODEL
70		// in doxygen or none of the following is rendered.
71		// set(DOXYGEN_PREDEFINED "TMB_MODEL=1" "ENABLE_TMB_CODE")
72
73		/**
74		* @brief The exponential function for a TMB model. The function specifically
75		* uses std::exp, defined in cmath header, instead of ::exp because the
76		* standard library function works with TMBad library, which is designed to
77		* recognize and apply its automatic differentiation capabilities to functions
78		* from the standard library. Also note that this function cannot be tested
79		* using the compilation flag -DTMB_MODEL through CMake and Google Test.
80		* @param x The value to exponentiate. Please use fims_math::exp<double>(x) if
81		* x is an integer.
82		* @return The exponentiated value of x.
83		*/
84		template <class Type>
85	2742020x	inline const Type exp(const Type &x) {
86		// use std::exp for double type, look for TMB version of exp if AD type
87		using std::exp;
88	2742020x	return exp(x);
89		}
90
91		/**
92		* @brief The natural log function (base e) for a TMB model. The function
93		* specifically uses std::log, defined in cmath header, instead of ::log
94		* because the standard library function works with TMBad library, which is
95		* designed to recognize and apply its automatic differentiation capabilities
96		* to functions from the standard library. Also note that this function cannot
97		* be tested using the compilation flag -DTMB_MODEL through CMake and Google
98		* Test.
99		* @param x The value to log. Please use fims_math::log<double>(x) if x is an
100		* integer.
101		* @return The natural log of x.
102		*/
103		template <class Type>
104	15882x	inline const Type log(const Type &x) {
105		// use std::log for double type, look for TMB version of log if AD type
106		using std::log;
107	15882x	return log(x);
108		}
109
110		/**
111		* @brief The cosine of an angle function for a TMB model. The function
112		* specifically uses std::cos, defined in cmath header, instead of ::cos
113		* because the standard library function works with TMBad library, which is
114		* designed to recognize and apply its automatic differentiation capabilities
115		* to functions from the standard library. Also note that this function cannot
116		* be tested using the compilation flag -DTMB_MODEL through CMake and Google
117		* Test.
118		* @param x The value to take the cosine of. Please use
119		* fims_math::cos<double>(x) if x is an integer.
120		* @return The cosine of the angle x.
121		*/
122		template <class Type>
123		inline const Type cos(const Type &x) {
124		// use std::cos for double type, look for TMB version of cos if AD type
125		using std::cos;
126		return cos(x);
127		}
128
129		/**
130		* @brief The square root function for a TMB model. The function specifically
131		* uses std::sqrt, defined in cmath header, instead of ::sqrt because the
132		* standard library function works with TMBad library, which is designed to
133		* recognize and apply its automatic differentiation capabilities to functions
134		* from the standard library. Also note that this function cannot be tested
135		* using the compilation flag -DTMB_MODEL through CMake and Google Test.
136		* @param x The value to take the square root of. Please use
137		* fims_math::sqrt<double>(x) if x is an integer.
138		* @return The square root of x.
139		*/
140		template <class Type>
141		inline const Type sqrt(const Type &x) {
142		// use std::std for double type, look for TMB version of std if AD type
143		using std::sqrt;
144		return sqrt(x);
145		}
146
147		/**
148		* @brief The power function for a TMB model. The function specifically uses
149		* std::pow, defined in cmath header, instead of ::pow because the standard
150		* library function works with TMBad library, which is designed to recognize
151		* and apply its automatic differentiation capabilities to functions from the
152		* standard library. Also note that this function cannot be tested using the
153		* compilation flag -DTMB_MODEL through CMake and Google Test.
154		* @param x The value to take the power of. Please use
155		* fims_math::pow<double>(x) if x is an integer.
156		* @param y The exponent to raise x to.
157		* @return The power of x.
158		*/
159		template <class Type>
160		inline const Type pow(const Type &x, const Type &y) {
161		// use std::pow for double type, look for TMB version of pow if AD type
162		using std::pow;
163		return pow(x, y);
164		}
165
166		/**
167		* @brief Computes the natural logarithm of the absolute value of the [gamma
168		* function](https://en.wikipedia.org/wiki/Gamma_function) of x for a TMB
169		* model. The function specifically uses std::lgamma, defined in cmath header,
170		* instead of ::lgamma because the standard library function works with TMBad
171		* library, which is designed to recognize and apply its automatic
172		* differentiation capabilities to functions from the standard library. Also
173		* note that this function cannot be tested using the compilation flag
174		* -DTMB_MODEL through CMake and Google Test.
175		* @param x The value to take the natural logarithm of the absolute value of
176		* the gamma function of. Please use fims_math::lgamma<double>(x) if x is an
177		* integer.
178		* @return The natural logarithm of the absolute value of the gamma function of
179		* x.
180		*/
181		template <class Type>
182		inline const Type lgamma(const Type &x) {
183		// use std::lgamma for double type, look for TMB version of lgamma if AD type
184		using std::lgamma;
185		return lgamma(x);
186		}
187
188		#endif
189
190		/**
191		* @brief The general logistic function
192		*
193		* @details
194		* The logistic function can range from zero to one or one to zero, depending on
195		* the slope parameter, but it is not normalized to force values to reach those
196		* ranges.
197		*
198		* \f$ \frac{1.0}{ 1.0 + exp(-1.0 * slope (x - inflection_point))} \f$
199		*
200		* @param inflection_point the inflection point of the logistic function
201		* @param slope the slope of the logistic function. A positive slope results in
202		* an ascending logistic curve (0 to 1), while a negative slope results in a
203		* descending logistic curve (1 to 0).
204		* @param x the index the logistic function should be evaluated at
205		* @return
206		*/
207		template <class Type>
208	1383102x	inline const Type logistic(const Type &inflection_point, const Type &slope,
209		const Type &x) {
210	246408x	return static_cast<Type>(1.0) /
211	1383102x	(static_cast<Type>(1.0) +
212	1629510x	exp(Type(-1.0) * slope * (x - inflection_point)));
213		}
214
215		/**
216		* @brief A logit function for bounding of parameters
217		*
218		* \f$ -\mathrm{log}(b-x) + \mathrm{log}(x-a) \f$
219		* @param a lower bound
220		* @param b upper bound
221		* @param x the parameter in bounded space
222		* @return the parameter in real space
223		*
224		*/
225		template <class Type>
226	5x	inline const Type logit(const Type &a, const Type &b, const Type &x) {
227	5x	return -fims_math::log(b - x) + fims_math::log(x - a);
228		}
229
230		/**
231		* @brief An inverse logit function for bounding of parameters
232		*
233		* \f$ a+\frac{b-a}{1+\mathrm{exp}(-\mathrm{logit}(x))}\f$
234		* @param a lower bound
235		* @param b upper bound
236		* @param logit_x the parameter in real space
237		* @return the parameter in bounded space
238		*
239		*/
240		template <class Type>
241	16404x	inline const Type inv_logit(const Type &a, const Type &b, const Type &logit_x) {
242	16404x	return a + (b - a) / (static_cast<Type>(1.0) + fims_math::exp(-logit_x));
243		}
244
245		/**
246		* @brief The general double logistic function
247		*
248		* \f$ \frac{1.0}{ 1.0 + exp(-1.0 * slope_{asc} (x - inflection_point_{asc}))}
249		* \left(1-\frac{1.0}{ 1.0 + exp(-1.0 * slope_{desc} (x -
250		* inflection_point_{desc}))} \right)\f$
251		*
252		* @param inflection_point_asc the inflection point of the ascending limb of the
253		* double logistic function
254		* @param slope_asc the slope of the ascending limb of the double logistic
255		* function
256		* @param inflection_point_desc the inflection point of the descending limb of
257		* the double logistic function, where inflection_point_desc >
258		* inflection_point_asc
259		* @param slope_desc the slope of the descending limb of the double logistic
260		* function
261		* @param x the index the logistic function should be evaluated at
262		* @return
263		*/
264
265		template <class Type>
266		inline const Type double_logistic(const Type &inflection_point_asc,
267		const Type &slope_asc,
268		const Type &inflection_point_desc,
269		const Type &slope_desc, const Type &x) {
270		return (static_cast<Type>(1.0)) /
271		(static_cast<Type>(1.0) +
272		exp(Type(-1.0) * slope_asc * (x - inflection_point_asc))) *
273		(static_cast<Type>(1.0) -
274		(static_cast<Type>(1.0)) /
275		(static_cast<Type>(1.0) +
276		exp(Type(-1.0) * slope_desc * (x - inflection_point_desc))));
277		}
278
279		/**
280		*
281		* Used when x could evaluate to zero, which will result in a NaN for
282		* derivative values.
283		*
284		* Evaluates:
285		*
286		* \f$ (x^2+C)^.5 \f$
287		*
288		* @param x value to keep positive
289		* @param C default = 1e-5
290		* @return
291		*/
292		template <class Type>
293		const Type ad_fabs(const Type &x, Type C = 1e-5) {
294		return sqrt((x * x) + C);
295		}
296
297		/**
298		*
299		* Returns the minimum between a and b in a continuous manner using:
300		*
301		* (a + b - fims_math::ad_fabs(a - b))*.5;
302		* Reference: \ref fims_math::ad_fabs()
303		*
304		* This is an approximation with minimal error.
305		*
306		* @param a
307		* @param b
308		* @param C default = 1e-5
309		* @return
310		*/
311
312		template <typename Type>
313		inline const Type ad_min(const Type &a, const Type &b, Type C = 1e-5) {
314		return (a + b - fims_math::ad_fabs(a - b, C)) * static_cast<Type>(0.5);
315		}
316
317		/**
318		* Returns the maximum between a and b in a continuous manner using:
319		*
320		* (a + b + fims_math::ad_fabs(a - b)) *.5;
321		* Reference: \ref fims_math::ad_fabs()
322		* This is an approximation with minimal error.
323		*
324		* @param a
325		* @param b
326		* @param C default = 1e-5
327		* @return
328		*/
329		template <typename Type>
330		inline const Type ad_max(const Type &a, const Type &b, Type C = 1e-5) {
331		return (a + b + fims_math::ad_fabs(a - b, C)) * static_cast<Type>(.5);
332		}
333
334		/**
335		* Sum elements of a vector
336		*
337		* @brief
338		*
339		* @param v A vector of constants.
340		* @return A single numeric value.
341		*/
342		template <class T>
343		T sum(const std::vector<T> &v) {
344		T ret = 0.0;
345		for (size_t i = 0; i < v.size(); i++) {
346		ret += v[i];
347		}
348		return ret;
349		}
350
351		/**
352		* Sum elements of a vector
353		*
354		* @brief
355		*
356		* @param v A vector of constants.
357		* @return A single numeric value.
358		*/
359		template <class T>
360		T sum(const fims::Vector<T> &v) {
361		T ret = 0.0;
362		for (size_t i = 0; i < v.size(); i++) {
363		ret += v[i];
364		}
365		return ret;
366		}
367
368		} // namespace fims_math
369
370		#endif /* FIMS_MATH_HPP */

1		/**
2		* @file fims_vector.hpp
3		* @brief Establishes the FIMS Vector class.
4		* @copyright This file is part of the NOAA, National Marine Fisheries Service
5		* Fisheries Integrated Modeling System project. See LICENSE in the source
6		* folder for reuse information.
7		*/
8		#ifndef FIMS_VECTOR_HPP
9		#define FIMS_VECTOR_HPP
10
11		#include "../interface/interface.hpp"
12		#include <ostream>
13		#include <iomanip>
14
15		namespace fims {
16
17		/**
18		* Wrapper class for std::vector types. If this file is compiled with
19		* -DTMB_MODEL, conversion operators are defined for TMB vector types.
20		*
21		* All std::vector functions are copied over from the std library. While some of
22		* these may not be called explicitly in FIMS, they may be required to run other
23		* std library functions.
24		*
25		*/
26		template <typename Type>
27		class Vector {
28		std::vector<Type> vec_m;
29		/**
30		* @brief friend comparison operator. Allows the operator to see private
31		* members of fims::Vector<Type>.
32		*/
33		template <typename T>
34		friend bool operator==(const fims::Vector<T> &lhs,
35		const fims::Vector<T> &rhs);
36
37		public:
38		// Member Types
39
40		typedef
41		typename std::vector<Type>::value_type value_type; /!<Member type Type>/
42		typedef typename std::vector<Type>::allocator_type
43		allocator_type; /!<Allocator for type Type>/
44		typedef typename std::vector<Type>::size_type size_type; /!<Size type>/
45		typedef typename std::vector<Type>::difference_type
46		difference_type; /!<Difference type>/
47		typedef typename std::vector<Type>::reference
48		reference; /!<Reference type &Type>/
49		typedef typename std::vector<Type>::const_reference
50		const_reference; /!<Constant reference type const &Type>/
51		typedef typename std::vector<Type>::pointer pointer; /!<Pointer type Type>*/
52		typedef typename std::vector<Type>::const_pointer
53		const_pointer; /!<Constant pointer type const Type>*/
54		typedef typename std::vector<Type>::iterator iterator; /!<Iterator>/
55		typedef typename std::vector<Type>::const_iterator
56		const_iterator; /!<Constant iterator>/
57		typedef typename std::vector<Type>::reverse_iterator
58		reverse_iterator; /!<Reverse iterator>/
59		typedef typename std::vector<Type>::const_reverse_iterator
60		const_reverse_iterator; /!<Constant reverse iterator>/
61
62		// Constructors
63
64		/**
65		* Default constructor.
66		*/
67	155238x	Vector() {}
68
69		/**
70		* @brief Constructs a Vector of length "size" and sets the elements with the
71		* value from input "value".
72		*/
73	7088x	Vector(size_t size, const Type &value = Type()) {
74	7088x	this->vec_m.resize(size, value);
75		}
76
77		/**
78		* @brief Copy constructor.
79		*/
80	45072x	Vector(const Vector<Type> &other) {
81	45072x	this->vec_m.resize(other.size());
82	2233802x	for (size_t i = 0; i < this->vec_m.size(); i++) {
83	2188730x	this->vec_m[i] = other[i];
84		}
85		}
86
87		/**
88		* @brief Assignment operator for fims::Vector.
89		*
90		* @details Assigns the contents of another fims::Vector to this
91		* vector. Cleans up existing contents and performs a deep copy.
92		*
93		* @param other The vector to assign from.
94		* @return Reference to this vector.
95		*/
96	25056x	Vector &operator=(const Vector &other) {
97	25056x	if (this != &other) {
98		// clean up existing
99	25056x	this->~Vector();
100		// copy construct into *this
101	25056x	new (this) Vector(other);
102		}
103	25056x	return *this;
104		}
105
106		/**
107		* @brief Initialization constructor from std::vector<Type> type.
108		*/
109		Vector(const std::vector<Type> &other) { this->vec_m = other; }
110
111		// TMB specific constructor
112		#ifdef TMB_MODEL
113
114		/**
115		* @brief Initialization constructor from tmbutils::vector<Type> type.
116		*/
117		Vector(const tmbutils::vector<Type> &other) {
118		this->vec_m.resize(other.size());
119		for (size_t i = 0; i < this->vec_m.size(); i++) {
120		this->vec_m[i] = other[i];
121		}
122		}
123
124		#endif
125
126		/**
127		* @brief Initialization constructor from std::initializer_list<Type> type.
128		*/
129	12528x	Vector(std::initializer_list<Type> init) {
130	12528x	this->vec_m = std::vector<Type>(init);
131		}
132
133		/**
134		* The following are std::vector functions copied over from the standard
135		* library. While some of these may not be called explicitly in FIMS, they may
136		* be required to run other std library functions.
137		*/
138
139		/**
140		* @brief Returns a reference to the element at specified location pos. No
141		* bounds checking is performed.
142		*/
143	52020600x	inline Type &operator[](size_t pos) {
144	52020600x	if (pos >= this->size()) {
145	!	throw std::invalid_argument("fims::Vector out of bounds");
146		}
147	52020600x	return this->vec_m[pos];
148		}
149
150		/**
151		* @brief Returns a constant reference to the element at specified location
152		* pos. No bounds checking is performed.
153		*/
154	2196314x	inline const Type &operator[](size_t n) const {
155	2196314x	if (n >= this->size()) {
156	!	throw std::invalid_argument("fims::Vector out of bounds");
157		}
158	2196314x	return this->vec_m[n];
159		}
160
161		/**
162		* @brief Returns a reference to the element at specified location pos. Bounds
163		* checking is performed.
164		*/
165	2806092x	inline Type &at(size_t n) { return this->vec_m.at(n); }
166
167		/**
168		* @brief Returns a constant reference to the element at specified location
169		* pos. Bounds checking is performed.
170		*/
171		inline const Type &at(size_t n) const { return this->vec_m.at(n); }
172
173		/**
174		* @brief If this vector is size 1 and pos is greater than zero,
175		* the first index is returned. If this vector has size
176		* greater than 1 and pos is greater than size, a invalid_argument
177		* exception is thrown. Otherwise, the value at index pos is returned.
178		*
179		* @param pos
180		* @return a constant reference to the element at specified location
181		*/
182	2806092x	inline Type &get_force_scalar(size_t pos) {
183	2806092x	if (this->size() == 1 && pos > 0) {
184	2682730x	return this->at(0);
185		} else if (this->size() > 1 && pos >= this->size()) {
186	!	throw std::invalid_argument(
187		"fims::Vector index out of bounds, check parameter sizes of input.");
188		} else {
189	123362x	return this->at(pos);
190		}
191		}
192
193		/**
194		* @brief Returns a reference to the first element in the container.
195		*/
196		inline reference front() { return this->vec_m.front(); }
197
198		/**
199		* @brief Returns a constant reference to the first element in the container.
200		*/
201		inline const_reference front() const { return this->vec_m.front(); }
202
203		/**
204		* @brief Returns a reference to the last element in the container.
205		*/
206		inline reference back() { return this->vec_m.back(); }
207
208		/**
209		* @brief Returns a constant reference to the last element in the container.
210		*/
211		inline const_reference back() const { return this->vec_m.back(); }
212
213		/**
214		* @brief Returns a pointer to the underlying data array.
215		*/
216		inline pointer data() { return this->vec_m.data(); }
217
218		/**
219		* @brief Returns a constant pointer to the underlying data array.
220		*/
221		inline const_pointer data() const { return this->vec_m.data(); }
222
223		// iterators
224
225		/**
226		* @brief Returns an iterator to the first element of the vector.
227		*/
228	166542x	inline iterator begin() { return this->vec_m.begin(); }
229
230		/**
231		* @brief Returns an iterator to the element following the last element of the
232		* vector.
233		*/
234	58422x	inline iterator end() { return this->vec_m.end(); }
235
236		/**
237		* @brief Returns a reverse iterator to the first element of the reversed
238		* vector. It corresponds to the last element of the non-reversed vector.
239		*/
240		inline reverse_iterator rbegin() { return this->vec_m.rbegin(); }
241
242		/**
243		* @brief Returns a reverse iterator to the element following the last element
244		* of the reversed vector. It corresponds to the element preceding the first
245		* element of the non-reversed vector.
246		*/
247		inline reverse_iterator rend() { return this->vec_m.rend(); }
248
249		/**
250		* @brief Returns a constant reverse iterator to the first element of the
251		* reversed vector. It corresponds to the last element of the non-reversed
252		* vector.
253		*/
254		inline const_reverse_iterator rbegin() const { return this->vec_m.rbegin(); }
255
256		/**
257		* @brief Returns a constant reverse iterator to the element following the
258		* last element of the reversed vector. It corresponds to the element
259		* preceding the first element of the non-reversed vector.
260		*/
261		inline const_reverse_iterator rend() const { return this->vec_m.rend(); }
262
263		// capacity
264
265		/**
266		* @brief Checks whether the container is empty.
267		*/
268		inline bool empty() { return this->vec_m.empty(); }
269
270		/**
271		* @brief Returns the number of elements.
272		*/
273	57131690x	inline size_type size() const { return this->vec_m.size(); }
274
275		/**
276		* @brief Returns the maximum possible number of elements.
277		*/
278		inline size_type max_size() const { return this->vec_m.max_size(); }
279
280		/**
281		* @brief Reserves storage.
282		*/
283		inline void reserve(size_type cap) { this->vec_m.reserve(cap); }
284
285		/**
286		* @brief Returns the number of elements that can be held in currently
287		* allocated storage.
288		*/
289		inline size_type capacity() { return this->vec_m.capacity(); }
290
291		/**
292		* @brief Reduces memory usage by freeing unused memory.
293		*/
294		inline void shrink_to_fit() { this->vec_m.shrink_to_fit(); }
295
296		// modifiers
297
298		/**
299		* @brief Clears the contents.
300		*/
301	888x	inline void clear() { this->vec_m.clear(); }
302
303		/**
304		* @brief Inserts value before pos.
305		*/
306		inline iterator insert(const_iterator pos, const Type &value) {
307		return this->vec_m.insert(pos, value);
308		}
309
310		/**
311		* @brief Inserts count copies of the value before pos.
312		*/
313		inline iterator insert(const_iterator pos, size_type count,
314		const Type &value) {
315		return this->vec_m.insert(pos, count, value);
316		}
317
318		/**
319		* @brief Inserts elements from range [first, last) before pos.
320		*/
321		template <class InputIt>
322		iterator insert(const_iterator pos, InputIt first, InputIt last) {
323		return this->vec_m.insert(pos, first, last);
324		}
325
326		/**
327		* @brief Inserts elements from initializer list ilist before pos.
328		*/
329
330		iterator insert(const_iterator pos, std::initializer_list<Type> ilist) {
331		return this->vec_m.insert(pos, ilist);
332		}
333
334		/**
335		* @brief Constructs element in-place.
336		*/
337		template <class... Args>
338		iterator emplace(const_iterator pos, Args &&...args) {
339		return this->vec_m.emplace(pos, std::forward<Args>(args)...);
340		}
341
342		/**
343		* @brief Removes the element at pos.
344		*/
345		inline iterator erase(iterator pos) { return this->vec_m.erase(pos); }
346
347		/**
348		* @brief Removes the elements in the range [first, last).
349		*/
350		inline iterator erase(iterator first, iterator last) {
351		return this->vec_m.erase(first, last);
352		}
353
354		/**
355		* @brief Adds an element to the end.
356		*/
357		inline void push_back(const Type &&value) { this->vec_m.push_back(value); }
358
359		/**
360		* @brief Constructs an element in-place at the end.
361		*/
362		template <class... Args>
363		void emplace_back(Args &&...args) {
364		this->vec_m.emplace_back(std::forward<Args>(args)...);
365		}
366
367		/**
368		* @brief Removes the last element.
369		*/
370		inline void pop_back() { this->vec_m.pop_back(); }
371
372		/**
373		* @brief Changes the number of elements stored.
374		*/
375	123834x	inline void resize(size_t s) { this->vec_m.resize(s); }
376
377		/**
378		* @brief Swaps the contents.
379		*/
380		inline void swap(Vector &other) { this->vec_m.swap(other.vec_m); }
381
382		// end std::vector functions
383
384		/**
385		* Conversion operators
386		*/
387
388		/**
389		* @brief Converts fims::Vector<Type> to std::vector<Type>
390		*/
391		inline operator std::vector<Type>() { return this->vec_m; }
392
393		#ifdef TMB_MODEL
394
395		/**
396		* @brief Converts fims::Vector<Type> to tmbutils::vector<Type>
397		*
398		* We provide both:
399		* 1. An explicit conversion operator (requires static_cast)
400		* 2. A named method `to_tmb()` for clarity
401		*/
402		explicit operator tmbutils::vector<Type>() const {
403		tmbutils::vector<Type> ret(this->vec_m.size());
404		for (size_t i = 0; i < this->vec_m.size(); i++) {
405		ret[i] = this->vec_m[i];
406		}
407		return ret;
408		}
409
410		/**
411		* @brief Converts fims::Vector<Type> to tmbutils::vector<Type>
412		*/
413		tmbutils::vector<Type> to_tmb() const {
414		tmbutils::vector<Type> ret(this->vec_m.size());
415		for (size_t i = 0; i < this->vec_m.size(); i++) {
416		ret[i] = this->vec_m[i];
417		}
418		return ret;
419		}
420
421		/**
422		* @brief Converts fims::Vector<Type> to tmbutils::vector<Type>
423		*
424		* We provide both:
425		* 1. An explicit conversion operator (requires static_cast)
426		* 2. A named method `to_tmb()` for clarity
427		*/
428		explicit operator tmbutils::vector<Type>() {
429		tmbutils::vector<Type> ret(this->vec_m.size());
430		for (size_t i = 0; i < this->vec_m.size(); i++) {
431		ret[i] = this->vec_m[i];
432		}
433		return ret;
434		}
435
436		/**
437		* @brief Converts fims::Vector<Type> to tmbutils::vector<Type>
438		*/
439	135954x	tmbutils::vector<Type> to_tmb() {
440	135954x	tmbutils::vector<Type> ret(this->vec_m.size());
441	8001520x	for (size_t i = 0; i < this->vec_m.size(); i++) {
442	7865566x	ret[i] = this->vec_m[i];
443		}
444	135954x	return ret;
445		}
446
447		#else
448
449		/**
450		* @brief Convert fims::Vector to std::vector.
451		*
452		* @details Returns a standard vector containing the same elements
453		* as the fims::Vector.
454		*
455		* @return std::vector<Type> with the same elements.
456		*/
457		std::vector<Type> to_std() const { return this->vec_m; }
458
459		/**
460		* @brief Convert fims::Vector to TMB vector type.
461		*
462		* @details Returns a TMB-compatible vector containing the same
463		* elements as the fims::Vector. Only available if compiled with
464		* TMB_MODEL.
465		*
466		* @return TMB vector type with the same elements.
467		*/
468		std::vector<Type> to_tmb() const { return this->vec_m; }
469		#endif
470
471		/**
472		* @brief Gets the tag for the vector. A tag can represent anything
473		* and is not used internally by FIMS.
474		* @return The tag.
475		*/
476		std::string get_tag() const { return this->tag_m; }
477		/**
478		* @brief Sets the tag for the vector. A tag can be set to
479		* any string value and is not used internally by FIMS.
480		*/
481		void set_tag(const std::string &tag) { this->tag_m = tag; }
482
483		private:
484		std::string tag_m; /!< The tag for the vector. /
485		}; // end fims::Vector class
486
487		/**
488		* @brief Comparison operator.
489		*/
490		template <class T>
491		bool operator==(const fims::Vector<T> &lhs, const fims::Vector<T> &rhs) {
492		return lhs.vec_m == rhs.vec_m;
493		}
494
495		} // namespace fims
496
497		/**
498		* @brief Output for std::ostream& for a vector.
499		*
500		* @param out The stream.
501		* @param v A vector.
502		* @return std::ostream&
503		*/
504		template <typename Type>
505		std::ostream &operator<<(std::ostream &out, const fims::Vector<Type> &v) {
506		out << std::fixed << std::setprecision(10);
507		out << "[";
508
509		if (v.size() == 0) {
510		out << "]";
511		return out;
512		}
513		for (size_t i = 0; i < v.size() - 1; i++) {
514		if (v[i] != v[i]) {
515		out << "-999" << ",";
516		} else {
517		out << v[i] << ",";
518		}
519		}
520		if (v[v.size() - 1] != v[v.size() - 1]) {
521		out << "-999]";
522		} else {
523		out << v[v.size() - 1] << "]";
524		}
525		return out;
526		}
527
528		#endif

1		/**
2		* @file model_object.hpp
3		* @brief Definition of the FIMSObject structure.
4		* @copyright This file is part of the NOAA, National Marine Fisheries Service
5		* Fisheries Integrated Modeling System project. See LICENSE in the source
6		* folder for reuse information.
7		*/
8
9		#ifndef FIMS_COMMON_MODEL_OBJECT_HPP
10		#define FIMS_COMMON_MODEL_OBJECT_HPP
11
12		#include <stdint.h>
13
14		#include <vector>
15
16		#include "def.hpp"
17		#include "fims_vector.hpp"
18
19		namespace fims_model_object {
20
21		/**
22		* @brief FIMSObject struct that defines member types and returns the unique id
23		*/
24		template <typename Type>
25		struct FIMSObject {
26		uint32_t id; /*< unique identifier assigned for all fims objects /
27		std::vector<Type> parameters; /< list of estimable parameters /
28		std::vector<Type*>
29		random_effects_parameters; /*< list of all random effects parameters /
30		std::vector<Type*>
31		fixed_effects_parameters; /*< list of fixed effects parameters /
32
33	1274x	virtual ~FIMSObject() {}
34
35		/**
36		* @brief Getter that returns the unique id for parameters in the model
37		*/
38	4593974x	uint32_t GetId() const { return id; }
39
40		/**
41		* @brief Check the dimensions of an object
42		*
43		* @param actual The actual dimensions.
44		* @param expected The expected dimensions.
45		* @return true
46		* @return false
47		*/
48		inline bool CheckDimensions(size_t actual, size_t expected) {
49		if (actual != expected) {
50		return false;
51		}
52
53		return true;
54		}
55		};
56
57		} // namespace fims_model_object
58
59		#endif /* FIMS_COMMON_MODEL_OBJECT_HPP */

1		/**
2		* @file model.hpp
3		* @brief : Loops over model components and returns the negative log-likelihood
4		* function.
5		* @copyright This file is part of the NOAA, National Marine Fisheries Service
6		* Fisheries Integrated Modeling System project. See LICENSE in the source
7		* folder for reuse information.
8		*/
9		#ifndef FIMS_COMMON_MODEL_HPP
10		#define FIMS_COMMON_MODEL_HPP
11
12		#include <future>
13		#include <memory>
14
15		#include "information.hpp"
16
17		namespace fims_model {
18
19		/**
20		* @brief Model class. FIMS objective function.
21		*/
22		template <typename Type>
23		class Model { // may need singleton
24		public:
25		static std::shared_ptr<Model<Type>>
26		fims_model; /*< Create a shared fims_model as a pointer to Model/
27		std::shared_ptr<fims_info::Information<Type>>
28		fims_information; /**< Create a shared fims_information as a pointer to
29		Information*/
30
31		#ifdef TMB_MODEL
32		bool do_tmb_reporting = true;
33		::objective_function<Type> *of;
34		#endif
35
36		// constructor
37
38	2x	virtual ~Model() {}
39
40		/**
41		* Returns a single Information object for type Type.
42		*
43		* @return singleton for type Type
44		*/
45	784x	static std::shared_ptr<Model<Type>> GetInstance() {
46	784x	if (Model<Type>::fims_model == nullptr) {
47	4x	Model<Type>::fims_model = std::make_shared<fims_model::Model<Type>>();
48	4x	Model<Type>::fims_model->fims_information =
49		fims_info::Information<Type>::GetInstance();
50		}
51	784x	return Model<Type>::fims_model;
52		}
53
54		/**
55		* @brief Evaluate. Calculates the joint negative log-likelihood function.
56		*/
57	704x	const Type Evaluate() {
58		// jnll = negative-log-likelihood (the objective function)
59	704x	Type jnll = static_cast<Type>(0.0);
60	704x	typename fims_info::Information<Type>::model_map_iterator m_it;
61		// Check if fims_information is set
62	704x	if (this->fims_information == nullptr) {
63	!	FIMS_ERROR_LOG(
64		"fims_information is not set. Please set fims_information before "
65		"calling Evaluate().");
66	!	return jnll;
67		}
68
69		// Create vector for reporting out nll components
70	842x	fims::Vector<Type> nll_vec(
71	704x	this->fims_information->density_components.size(), 0.0);
72
73	1232x	for (m_it = this->fims_information->models_map.begin();
74	1232x	m_it != this->fims_information->models_map.end(); ++m_it) {
75		//(*m_it).second points to the Model module
76	528x	std::shared_ptr<fims_popdy::FisheryModelBase<Type>> m = (*m_it).second;
77	528x	m->of = this->of; // link to TMB objective function
78	528x	m->Prepare();
79	528x	m->Evaluate();
80		}
81
82		// Loop over densities and evaluate joint negative log densities for priors
83	704x	typename fims_info::Information<Type>::density_components_iterator d_it;
84	704x	int nll_vec_idx = 0;
85	704x	size_t n_priors = 0;
86	1408x	FIMS_INFO_LOG("Begin evaluating prior densities.")
87	4160x	for (d_it = this->fims_information->density_components.begin();
88	4160x	d_it != this->fims_information->density_components.end(); ++d_it) {
89	3456x	std::shared_ptr<fims_distributions::DensityComponentBase<Type>> d =
90	3456x	(*d_it).second;
91		#ifdef TMB_MODEL
92	3456x	d->of = this->of;
93		#endif
94	3456x	if (d->input_type == "prior") {
95	38x	nll_vec[nll_vec_idx] = -d->evaluate();
96	38x	jnll += nll_vec[nll_vec_idx];
97	38x	n_priors += 1;
98	38x	nll_vec_idx += 1;
99		}
100		}
101	704x	FIMS_INFO_LOG(
102		"Model: Finished evaluating prior distributions. The jnll after "
103		"evaluating " +
104		fims::to_string(n_priors) + " priors is: " + fims::to_string(jnll));
105
106		// Loop over densities and evaluate joint negative log-likelihoods for
107		// random effects
108	704x	size_t n_random_effects = 0;
109	4160x	for (d_it = this->fims_information->density_components.begin();
110	4160x	d_it != this->fims_information->density_components.end(); ++d_it) {
111	3456x	std::shared_ptr<fims_distributions::DensityComponentBase<Type>> d =
112	3456x	(*d_it).second;
113		#ifdef TMB_MODEL
114	3456x	d->of = this->of;
115		#endif
116	3456x	if (d->input_type == "random_effects") {
117	558x	nll_vec[nll_vec_idx] = -d->evaluate();
118	558x	jnll += nll_vec[nll_vec_idx];
119	558x	n_random_effects += 1;
120	558x	nll_vec_idx += 1;
121		}
122		}
123	704x	FIMS_INFO_LOG(
124		"Model: Finished evaluating random effect distributions. The jnll "
125		"after evaluating priors and " +
126		fims::to_string(n_random_effects) +
127		" random_effects is: " + fims::to_string(jnll));
128
129		// Loop over and evaluate data joint negative log-likelihoods
130	704x	int n_data = 0;
131	4160x	for (d_it = this->fims_information->density_components.begin();
132	4160x	d_it != this->fims_information->density_components.end(); ++d_it) {
133	3456x	std::shared_ptr<fims_distributions::DensityComponentBase<Type>> d =
134	3456x	(*d_it).second;
135		#ifdef TMB_MODEL
136	3456x	d->of = this->of;
137		// d->keep = this->keep;
138		#endif
139	3456x	if (d->input_type == "data") {
140	2860x	nll_vec[nll_vec_idx] = -d->evaluate();
141	2860x	jnll += nll_vec[nll_vec_idx];
142	2860x	n_data += 1;
143	2860x	nll_vec_idx += 1;
144		}
145		}
146
147		// report out nll components
148		#ifdef TMB_MODEL
149	704x	vector<Type> nll_components = nll_vec.to_tmb();
150	566x	FIMS_REPORT_F(nll_components, this->of);
151	566x	FIMS_REPORT_F(jnll, this->of);
152		#endif
153
154		// report out model family objects
155	1232x	for (m_it = this->fims_information->models_map.begin();
156	1232x	m_it != this->fims_information->models_map.end(); ++m_it) {
157		//(*m_it).second points to the Model module
158	528x	std::shared_ptr<fims_popdy::FisheryModelBase<Type>> m = (*m_it).second;
159	528x	m->Report();
160		}
161
162	704x	return jnll;
163		}
164		};
165
166		// Create singleton instance of Model class
167		template <typename Type>
168		std::shared_ptr<Model<Type>> Model<Type>::fims_model =
169		nullptr; // singleton instance
170		} // namespace fims_model
171
172		#endif /* FIMS_COMMON_MODEL_HPP */

1
2		/**
3		* @file density_components_base.hpp
4		* @brief Declares the DensityComponentBase class, which is the base class for
5		* all distribution functors.
6		* @details This header defines two core templates used by concrete
7		* distribution functors (e.g., NormalLPDF, LogNormalLPDF, MultinomialLPMF):
8		* DistributionElementObject, which stores and resolves observed/expected
9		* inputs, and DensityComponentBase, which adds shared bookkeeping for
10		* log-likelihood contributions and simulation/reporting behavior.
11		* @copyright This file is part of the NOAA, National Marine Fisheries Service
12		* Fisheries Integrated Modeling System project. See LICENSE in the source
13		* folder for reuse information.
14		*/
15		#ifndef DENSITY_COMPONENT_BASE_HPP
16		#define DENSITY_COMPONENT_BASE_HPP
17
18		#include "../../common/data_object.hpp"
19		#include "../../common/model_object.hpp"
20		#include "../../interface/interface.hpp"
21		#include "../../common/fims_vector.hpp"
22		#include "../../common/fims_math.hpp"
23
24		namespace fims_distributions {
25
26		/** @brief Base class for all module_name functors.
27		*
28		* @tparam Type The type of the module_name functor.
29		*
30		*/
31		template <typename Type>
32		struct DensityComponentBase : public fims_model_object::FIMSObject<Type> {
33		/**
34		* @brief Classification of the input pathway for this distribution object.
35		* Options used by accessor methods are, "prior", "random_effects", and
36		*"data".
37		*/
38		std::string input_type;
39
40		/** @brief Observed data. */
41		std::shared_ptr<fims_data_object::DataObject<Type>> data_observed_values;
42
43		/** @brief Expected value vector for prior-based pathways. */
44		fims::Vector<Type> expected_values;
45
46		/** @brief Pointer to random effects vector. */
47		fims::Vector<Type>* re = NULL;
48
49		/** @brief Expected value vector for random-effects pathways. */
50		fims::Vector<Type>* re_expected_values = NULL;
51
52		/** @brief Expected value vector for data pathways. */
53		fims::Vector<Type>* data_expected_values = NULL;
54
55		/** @brief Vector of pointers where each entry points to a prior parameter. */
56		std::vector<fims::Vector<Type>*> priors;
57
58		/**
59		* @brief Input value of distribution function for priors or random effects.
60		*/
61		fims::Vector<Type> observed_values;
62
63		/**
64		* @brief The expected mean of the distribution; overrides expected values.
65		*/
66		fims::Vector<Type> expected_mean;
67
68		/**
69		* @brief If "yes", `expected_mean` is used instead of `expected_values`. The
70		* default is "no" leading to the use of `expected_values`.
71		*/
72		std::string use_mean = fims::to_string("no");
73
74		// std::shared_ptr<DistributionElementObject<Type>> expected;
75		// // Expected value of distribution function.
76
77		/**
78		* @brief Retrieve one observed value based on `input_type`.
79		* @param i Index into the active observed source, e.g., vector or pointer.
80		* @return Reference to the selected observed value.
81		* @throws std::runtime_error If input_type is "prior" and priors is empty.
82		*/
83	119166x	inline Type& get_observed(size_t i) {
84	119166x	if (this->input_type == "data") {
85	99428x	return data_observed_values->at(i);
86		}
87	19738x	if (this->input_type == "random_effects") {
88	18496x	return (*re)[i];
89		}
90	1242x	if (this->input_type == "prior") {
91	1016x	if (priors.size() == 0) {
92	!	throw std::runtime_error("No priors defined for this distribution.");
93	1016x	} else if (priors.size() == 1) {
94	984x	return (*(priors[0]))[i];
95	32x	} else if (priors.size() > 1) {
96	32x	return (*(priors[i]))[0];
97		}
98		}
99	113x	return observed_values[i];
100		}
101
102		/**
103		* @brief Retrieve one observed matrix-like value based on `input_type`.
104		* @param i Row index.
105		* @param j Column index.
106		* @return Reference to the selected observed value.
107		*/
108	1938458x	inline Type& get_observed(size_t i, size_t j) {
109	1938458x	if (this->input_type == "data") {
110	1938458x	return data_observed_values->at(i, j);
111		}
112	!	return observed_values[i * (j - 1) + j];
113		}
114
115		/**
116		* @brief Retrieve one expected value based on `input_type` and `use_mean`.
117		* @param i Index into the active expected source, e.g., vector or pointer.
118		* @return Reference to the selected expected value.
119		* @details If `use_mean == "yes"`, `expected_mean` overrides other expected
120		* vectors and is accessed via scalar/vector semantics.
121		*/
122	1066402x	inline Type& get_expected(size_t i) {
123	1066402x	if (this->input_type == "data") {
124	1046720x	return (*data_expected_values)[i];
125	19682x	} else if (this->use_mean == "yes") {
126	960x	return this->expected_mean.get_force_scalar(i);
127	18722x	} else if (this->input_type == "random_effects") {
128	17536x	return (*re_expected_values)[i];
129		} else {
130	1186x	return this->expected_values.get_force_scalar(i);
131		}
132		}
133
134		/**
135		* @brief Get length of the active observed input vector.
136		* @return Size of the observed input under the current `input_type`.
137		*/
138	1844x	inline size_t get_n_x() {
139	1844x	if (this->input_type == "data") {
140	1152x	return this->data_observed_values->data.size();
141		}
142	692x	if (this->input_type == "random_effects") {
143	608x	return (*re).size();
144		}
145	84x	if (this->input_type == "prior") {
146	40x	return this->expected_values.size();
147		}
148	22x	return observed_values.size();
149		}
150
151		/**
152		* @brief Get length of the active expected input vector.
153		* @return Size of the expected input under the current `input_type`.
154		*/
155	1696x	inline size_t get_n_expected() {
156	1696x	if (this->input_type == "data") {
157	1056x	return (*data_expected_values).size();
158		}
159	640x	if (this->input_type == "random_effects") {
160	558x	return (*re_expected_values).size();
161		}
162	82x	if (this->input_type == "prior") {
163	38x	return this->expected_values.size();
164		}
165	22x	return observed_values.size();
166		}
167		// id_g is the ID of the instance of the DensityComponentBase class.
168		// this is like a memory tracker.
169		// Assigning each one its own ID is a way to keep track of
170		// all the instances of the DensityComponentBase class.
171		/**
172		* @brief Global unique identifier for distribution modules.
173		*/
174		static uint32_t id_g;
175
176		/**
177		* @brief Total log probability density contribution of the distribution.
178		*
179		*/
180		Type lpdf;
181
182		/**
183		* @brief ID of observed data component.
184		*/
185		int observed_data_id_m = -999;
186
187		/**
188		* @brief Vector storing observation-level log-likelihood contributions.
189		*/
190		fims::Vector<Type> lpdf_vec;
191
192		/**
193		* @brief Boolean; if true, one-step-ahead (OSA) residuals are calculated.
194		*/
195		bool osa_flag = false;
196
197		/**
198		* @brief Boolean; if true, data are simulated from the distribution.
199		*/
200		bool simulate_flag = false;
201
202		/**
203		* @brief Unique ID for variable map that points to a fims::Vector.
204		*/
205		std::vector<uint32_t> key;
206
207		#ifdef TMB_MODEL
208		/**
209		* @brief Pointer to the TMB objective function.
210		*/
211		::objective_function<Type>* of;
212		#endif
213
214		/**
215		* @brief Constructor, which initializes default prior pointer state and ID.
216		*/
217	830x	DensityComponentBase() {
218		// initialize the priors vector with a size of 1 and set the first element
219		// to NULL
220	830x	this->priors.resize(1);
221	830x	this->priors[0] = NULL;
222	830x	this->id = DensityComponentBase::id_g++;
223		}
224
225	415x	virtual ~DensityComponentBase() {}
226		/**
227		* @brief Evaluate the distribution-specific log-likelihood contribution.
228		* @return Total log-likelihood contribution for the active inputs.
229		*/
230		virtual const Type evaluate() = 0;
231		};
232
233		/** @brief Default id of the singleton distribution class
234		*/
235		template <typename Type>
236		uint32_t DensityComponentBase<Type>::id_g = 0;
237
238		} // namespace fims_distributions
239
240		#endif /* DENSITY_COMPONENT_BASE_HPP */

1		/**
2		* @file lognormal_lpdf.hpp
3		* @brief Implements the LogNormalLPDF distribution functor used by FIMS to
4		* evaluate observation-level and total log-likelihood contributions under a
5		* lognormal error model for data, priors, and random effects.
6		* @copyright This file is part of the NOAA, National Marine Fisheries Service
7		* Fisheries Integrated Modeling System project. See LICENSE in the source
8		* folder for reuse information.
9		*/
10		#ifndef LOGNORMAL_LPDF
11		#define LOGNORMAL_LPDF
12
13		#include "density_components_base.hpp"
14		#include "../../common/fims_vector.hpp"
15		#include "../../common/def.hpp"
16
17		namespace fims_distributions {
18		/**
19		* @copybrief lognormal_lpdf.hpp
20		*
21		* @details This implementation relies on [TMB's R-style `dnorm()` utility](
22		* https://kaskr.github.io/adcomp/group__R__style__distribution.html) for
23		* normal log-density calculations on log-transformed values. Specifically,
24		* when evaluating the lognormal likelihood, observations are transformed with
25		* `log(x)` and passed to `dnorm(..., give_log = true)` to obtain log-density
26		* values. For data inputs, the Jacobian adjustment `-log(x)` is applied where
27		* appropriate to convert from normal density on the log scale to the lognormal
28		* density on the original scale.
29		*
30		* For `data` input, values equal to `na_value` are skipped and contribute zero
31		* to the objective. Per-observation contributions are stored in `lpdf_vec`;
32		* the summed total is returned by `evaluate()` and stored in `lpdf`.
33		*/
34		template <typename Type>
35		struct LogNormalLPDF : public DensityComponentBase<Type> {
36		/**
37		* @brief Natural log of the standard deviation of the distribution on the
38		* log scale. The argument can be a vector or scalar, where the latter is
39		* referenced for each instance through the use of
40		* \ref fims::Vector::get_force_scalar(size_t) "get_force_scalar()".
41		*/
42		fims::Vector<Type> log_sd;
43
44		/** @brief Constructor.
45		*/
46	254x	LogNormalLPDF() : DensityComponentBase<Type>() {}
47
48		/** @brief Destructor.
49		*/
50	127x	virtual ~LogNormalLPDF() {}
51
52		/**
53		* @brief Evaluates the lognormal log probability density function.
54		* @details The following equation is the lognormal probability density
55		* function, and thus, the log of it is evaluated:
56		* \f[
57		* f(x) = \frac{1.0}{ x\sigma\sqrt{2\pi}
58		* }\mathrm{exp}\Bigg(-\frac{(\mathrm{ln}(x) - \mu)^{2}}{2\sigma^{2}}\Bigg),
59		* \f]
60		* where \f$\mu\f$ is the mean of the distribution of \f$\mathrm{ln(x)}\f$
61		* and \f$\sigma^2\f$ is the variance of \f$\mathrm{ln}(x)\f$.
62		*/
63	1078x	virtual const Type evaluate() {
64		// set vector size based on input type (prior, process, or data)
65	1078x	size_t n_x = this->get_n_x();
66		// get expected value vector size
67	1078x	size_t n_expected = this->get_n_expected();
68		// setup vector for recording the log probability density function values
69	1078x	this->lpdf_vec.resize(n_x);
70	1078x	std::fill(this->lpdf_vec.begin(), this->lpdf_vec.end(),
71	1078x	static_cast<Type>(0));
72	1078x	this->lpdf = static_cast<Type>(0);
73
74		// Dimension checks
75		// TODO: fix dimension check as expected values no longer used for data
76	1078x	if (n_x != n_expected) {
77	!	if (n_expected == 1) {
78	!	n_expected = n_x;
79	!	} else if (n_x > n_expected) {
80	!	n_x = n_expected;
81		}
82		}
83
84	445x	if (this->log_sd.size() > 1 && n_x != this->log_sd.size()) {
85	1x	throw std::invalid_argument(
86		"LognormalLPDF::Vector index out of bounds. The size of observed "
87		"data does not equal the size of the log_sd vector. The observed "
88		"data vector is of size " +
89		fims::to_string(n_x) + " and the log_sd vector is of size " +
90		fims::to_string(this->log_sd.size()));
91		}
92
93	33912x	for (size_t i = 0; i < n_x; i++) {
94		#ifdef TMB_MODEL
95	32836x	if (this->input_type == "data") {
96		// if data, check if there are any NA values and skip lpdf calculation
97		// if there are See Deroba and Miller, 2016
98		// (https://doi.org/10.1016/j.fishres.2015.12.002) for the use of
99		// lognormal constant
100	32780x	if (this->get_observed(i) != this->data_observed_values->na_value) {
101	31834x	this->lpdf_vec[i] =
102	31834x	dnorm(log(this->get_observed(i)), this->get_expected(i),
103	37502x	fims_math::exp(log_sd.get_force_scalar(i)), true) -
104	37502x	log(this->get_observed(i));
105		} else {
106	946x	this->lpdf_vec[i] = 0;
107		}
108		} else {
109	28x	if (this->input_type == "random_effects") {
110		// if random effects, no lognormal constant needs to be applied
111	!	this->lpdf_vec[i] =
112	!	dnorm(log(this->get_observed(i)), this->get_expected(i),
113	!	fims_math::exp(log_sd.get_force_scalar(i)), true);
114		} else {
115	28x	this->lpdf_vec[i] =
116	28x	dnorm(log(this->get_observed(i)), this->get_expected(i),
117	28x	fims_math::exp(log_sd.get_force_scalar(i)), true) -
118	28x	log(this->get_observed(i));
119		}
120		}
121
122	32836x	this->lpdf += this->lpdf_vec[i];
123	32836x	if (this->simulate_flag) {
124	!	FIMS_SIMULATE_F(this->of) { // preprocessor definition in interface.hpp
125		// this simulates data that is mean biased
126	!	if (this->input_type == "data") {
127	!	this->data_observed_values->at(i) = fims_math::exp(
128	!	rnorm(this->get_expected(i),
129	!	fims_math::exp(log_sd.get_force_scalar(i))));
130		}
131	!	if (this->input_type == "random_effects") {
132	!	(*this->re)[i] = fims_math::exp(
133	!	rnorm(this->get_expected(i),
134	!	fims_math::exp(log_sd.get_force_scalar(i))));
135		}
136	!	if (this->input_type == "prior") {
137	!	(*(this->priors[i]))[0] = fims_math::exp(
138	!	rnorm(this->get_expected(i),
139	!	fims_math::exp(log_sd.get_force_scalar(i))));
140		}
141		}
142		}
143		#endif
144		}
145		#ifdef TMB_MODEL
146	1076x	vector<Type> lognormal_observed_values = this->observed_values.to_tmb();
147		// FIMS_REPORT_F(lognormal_observed_values, this->of);
148		#endif
149	1076x	return (this->lpdf);
150		}
151		};
152		} // namespace fims_distributions
153		#endif

1		/**
2		* @file multinomial_lpmf.hpp
3		* @brief Implements the MultinomialLPMF distribution functor used by FIMS to
4		* evaluate the observation-level and total log-likelihood contributions under
5		* a multinomial error model for data, priors, and random effects.
6		* @copyright This file is part of the NOAA, National Marine Fisheries Service
7		* Fisheries Integrated Modeling System project. See LICENSE in the source
8		* folder for reuse information.
9		*/
10		#ifndef MULTINOMIAL_LPMF
11		#define MULTINOMIAL_LPMF
12
13		#include "density_components_base.hpp"
14		#include "../../common/fims_vector.hpp"
15		#include "../../common/def.hpp"
16
17		namespace fims_distributions {
18		/**
19		* @copybrief multinomial_lpmf.hpp
20		*
21		* @details This implementation relies on [TMB's R-style `dmultinom()`
22		* utility]( https://kaskr.github.io/adcomp/group__R__style__distribution.html)
23		* to compute row-wise multinomial log-probability mass contributions from
24		* observed counts (`x_vector`) and expected proportions (`prob_vector`).
25		* Specifically, when evaluating the multinomial likelihood, observations are
26		* passed to `dmultinom(..., give_log = true)`.
27		*
28		* For `data` input, if any element in a row is equal to `na_value`, the entire
29		* row is skipped and contributes zero to the objective. Contributions are
30		* stored in `lpdf_vec`. The summed total is returned by `evaluate()` and
31		* stored in `lpdf`.
32		*
33		* Row observations could be counts of each age for a given time step, where
34		* additional time steps would be additional rows. Thus, columns are bins.
35		*/
36		template <typename Type>
37		struct MultinomialLPMF : public DensityComponentBase<Type> {
38		/**
39		* @brief Dimensions of the number of rows and columns of the multivariate
40		* dataset.
41		*/
42		fims::Vector<size_t> dims;
43
44		/** @brief Constructor.
45		*/
46	418x	MultinomialLPMF() : DensityComponentBase<Type>() {}
47
48		/** @brief Destructor.
49		*/
50	209x	virtual ~MultinomialLPMF() {}
51
52		/**
53		* @brief Evaluates the multinomial log probability mass function.
54		* @details The following equation is the multinomial probability mass
55		* function, and thus, the log of it is evaluated:
56		* \f[
57		* f(\underline{y}) = \frac{n!}{y_{1}!...
58		* y_{k}!}p^{y_{1}}_{1}...p^{y_{k}}_{k}, \f] where \f$k\f$ is the number of
59		* categories, \f$n\f$ is the sample size, \f$\mu_{i}\f$ is the mean of
60		* \f$y_{i}\f$ and is equal to \f$np_{i}\f$, and \f$\sigma^{2}_{i}\f$ is the
61		* variance of \f$y_{i}\f$ and is equal to \f$np_{i}(1-p_{i})\f$.
62		*/
63	907x	virtual const Type evaluate() {
64		// set dims using data_observed_values if no user input
65	907x	if (dims.size() != 2) {
66	172x	dims.resize(2);
67	172x	dims[0] = this->data_observed_values->get_imax();
68	172x	dims[1] = this->data_observed_values->get_jmax();
69		}
70
71		// setup vector for recording the log probability density function values
72	907x	this->lpdf = static_cast<Type>(0.0); /**< total log probability mass
73		contribution of the distribution */
74	907x	this->lpdf_vec.resize(dims[0] * dims[1]);
75	907x	std::fill(this->lpdf_vec.begin(), this->lpdf_vec.end(), 0);
76	907x	size_t lpdf_vec_idx = 0; /*< index for lpdf_vec vector /
77		// Dimension checks
78	907x	if (this->input_type == "data") {
79	902x	if (this->data_expected_values) {
80	902x	if (dims[0] * dims[1] != this->data_expected_values->size()) {
81	!	throw std::invalid_argument(
82		"MultinomialLPDF: Vector index out of bounds. The dimension of "
83		"the "
84		"number of rows times the number of columns is of size " +
85	!	fims::to_string(dims[0] * dims[1]) +
86		" and the expected vector is of size " +
87	!	fims::to_string(this->data_expected_values->size()));
88		}
89		}
90		} else {
91		if (dims[0] * dims[1] != this->observed_values.size()) {
92		throw std::invalid_argument(
93		"MultinomialLPDF: Vector index out of bounds. The dimension of the "
94		"number of rows times the number of columns is of size " +
95		fims::to_string(dims[0] * dims[1]) +
96		" and the observed vector is of size " +
97		fims::to_string(this->observed_values.size()));
98		}
99		if (this->observed_values.size() != this->expected_values.size()) {
100		throw std::invalid_argument(
101		"MultinomialLPDF: Vector index out of bounds. The dimension of the "
102		"observed vector of size " +
103		fims::to_string(this->observed_values.size()) +
104		" and the expected vector is of size " +
105		fims::to_string(this->expected_values.size()));
106		}
107		}
108
109	29068x	for (size_t i = 0; i < dims[0]; i++) {
110		// for each row, create new observed_values and prob vectors
111	28163x	fims::Vector<Type> observed_values_vector;
112	28163x	fims::Vector<Type> prob_vector;
113	28163x	observed_values_vector.resize(dims[1]);
114	28163x	prob_vector.resize(dims[1]);
115
116		// Skips the entire row if any values are NA
117	28163x	bool containsNA = false;
118
119		#ifdef TMB_MODEL
120	490336x	for (size_t j = 0; j < dims[1]; j++) {
121	463306x	if (this->input_type == "data") {
122		// if data, check if there are any NA values and skip lpdf calculation
123		// for entire row if there are
124	627540x	if (this->get_observed(static_cast<size_t>(i),
125	844420x	static_cast<size_t>(j)) ==
126	463276x	this->data_observed_values->na_value) {
127	1133x	containsNA = true;
128	1133x	break;
129		}
130	462143x	if (!containsNA) {
131	462143x	size_t idx = (i * dims[1]) + j;
132	462143x	observed_values_vector[j] = this->get_observed(i, j);
133	462143x	prob_vector[j] = this->get_expected(idx);
134		}
135		} else {
136		// if not data (i.e. prior or process), use observed_values vector
137		// instead of data_observed_values
138		size_t idx = (i * dims[1]) + j;
139		observed_values_vector[j] = this->get_observed(idx);
140		prob_vector[j] = this->get_expected(idx);
141		}
142		}
143
144	28163x	if (!containsNA) {
145	27030x	std::fill(this->lpdf_vec.begin() + lpdf_vec_idx,
146	27030x	this->lpdf_vec.begin() + lpdf_vec_idx + dims[1],
147	54060x	dmultinom(observed_values_vector.to_tmb(),
148		prob_vector.to_tmb(), true));
149
150	27030x	this->lpdf += this->lpdf_vec[lpdf_vec_idx];
151		} else {
152	1133x	this->lpdf_vec[i] = 0;
153		}
154	28163x	lpdf_vec_idx += dims[1];
155		/*
156		if (this->simulate_flag)
157		{
158		FIMS_SIMULATE_F(this->of)
159		{
160		fims::Vector<Type> sim_observed;
161		sim_observed.resize(dims[1]);
162		sim_observed = rmultinom(prob_vector);
163		sim_observed.resize(this->observed_values.size());
164		for (size_t j = 0; j < dims[1]; j++)
165		{
166		idx = (i * dims[1]) + j;
167		this->observed_values[idx] = sim_observed[j];
168		}
169		}
170		}
171		*/
172		#endif
173		}
174
175		#ifdef TMB_MODEL
176		#endif
177	905x	return (this->lpdf);
178		}
179		};
180		} // namespace fims_distributions
181		#endif

1		/**
2		* @file normal_lpdf.hpp
3		* @brief Implements the NormalLPDF distribution functor used by FIMS to
4		* evaluate observation-level and total log-likelihood contributions under a
5		* normal error model for data, priors, and random effects.
6		* @copyright This file is part of the NOAA, National Marine Fisheries Service
7		* Fisheries Integrated Modeling System project. See LICENSE in the source
8		* folder for reuse information.
9		*/
10
11		#ifndef NORMAL_LPDF
12		#define NORMAL_LPDF
13
14		#include "density_components_base.hpp"
15		#include "../../common/fims_vector.hpp"
16		#include "../../common/def.hpp"
17
18		namespace fims_distributions {
19		/**
20		* @copybrief normal_lpdf.hpp
21		*
22		* @details This implementation relies on [TMB's R-style `dnorm()` utility](
23		* https://kaskr.github.io/adcomp/group__R__style__distribution.html) for
24		* normal log-density calculations. Specifically, when evaluating the normal
25		* likelihood, observations are passed to `dnorm(..., give_log = true)` to
26		* obtain log-density values.
27		*
28		* For `data` input, values equal to `na_value` are skipped and contribute zero
29		* to the objective. Per-observation contributions are stored in `lpdf_vec`;
30		* the summed total is returned by `evaluate()` and stored in `lpdf`.
31		*/
32		template <typename Type>
33		struct NormalLPDF : public DensityComponentBase<Type> {
34		/**
35		* @brief The natural log of the standard deviation of the distribution. The
36		* argument can be a vector or scalar, where the latter is referenced for
37		* each instance through the use of
38		* \ref fims::Vector::get_force_scalar(size_t) "get_force_scalar()".
39		*/
40		fims::Vector<Type> log_sd;
41
42		/** @brief Constructor.
43		*/
44	158x	NormalLPDF() : DensityComponentBase<Type>() {}
45
46		/** @brief Destructor.
47		*/
48	79x	virtual ~NormalLPDF() {}
49
50		/**
51		* @brief Evaluates the normal log probability density function.
52		* @details The following equation is normal probability density function,
53		* and thus, the log of it evaluated:
54		* \f[
55		* f(x) =
56		* \frac{1}{\sigma\sqrt{2\pi}}\mathrm{exp}\Bigg(-\frac{(x-\mu)^2}{2\sigma^2}
57		* \Bigg), \f] where \f$\mu\f$ is the mean of the distribution and
58		* \f$\sigma^2\f$ is the variance.
59		*/
60	618x	virtual const Type evaluate() {
61		// set vector size based on input type (prior, process, or data)
62	618x	size_t n_x = this->get_n_x();
63		// get expected value vector size
64	618x	size_t n_expected = this->get_n_expected();
65		// setup vector for recording the log probability density function values
66	618x	this->lpdf_vec.resize(n_x);
67	618x	std::fill(this->lpdf_vec.begin(), this->lpdf_vec.end(),
68	618x	static_cast<Type>(0));
69	618x	this->lpdf = static_cast<Type>(0);
70
71		// Dimension checks
72	618x	if (n_x != n_expected) {
73	22x	if (n_expected == 1) {
74	!	n_expected = n_x;
75	22x	} else if (n_x > n_expected) {
76	!	n_x = n_expected;
77		}
78		}
79
80	255x	if (this->log_sd.size() > 1 && n_x != this->log_sd.size()) {
81	2x	throw std::invalid_argument(
82		"NormalLPDF::Vector index out of bounds. The size of observed data "
83		"does not equal the size of the log_sd vector. The observed data "
84		"vector is of size " +
85		fims::to_string(n_x) + " and the log_sd vector is of size " +
86		fims::to_string(this->log_sd.size()));
87		}
88
89	18576x	for (size_t i = 0; i < n_x; i++) {
90		#ifdef TMB_MODEL
91	17962x	if (this->input_type == "data") {
92		// if data, check if there are any NA values and skip lpdf calculation
93		// if there are
94	!	if (this->get_observed(i) != this->data_observed_values->na_value) {
95	!	this->lpdf_vec[i] =
96	!	dnorm(this->get_observed(i), this->get_expected(i),
97	!	fims_math::exp(log_sd.get_force_scalar(i)), true);
98		} else {
99	!	this->lpdf_vec[i] = 0;
100		}
101		// if not data (i.e. prior or process), use x vector instead of
102		// observed_values
103		} else {
104	17962x	this->lpdf_vec[i] =
105	17962x	dnorm(this->get_observed(i), this->get_expected(i),
106	17962x	fims_math::exp(log_sd.get_force_scalar(i)), true);
107		}
108	17962x	this->lpdf += this->lpdf_vec[i];
109	17962x	if (this->simulate_flag) {
110	!	FIMS_SIMULATE_F(this->of) {
111	!	if (this->input_type == "data") {
112	!	this->data_observed_values->at(i) =
113	!	rnorm(this->get_expected(i),
114	!	fims_math::exp(log_sd.get_force_scalar(i)));
115		}
116	!	if (this->input_type == "random_effects") {
117	!	(*this->re)[i] = rnorm(this->get_expected(i),
118	!	fims_math::exp(log_sd.get_force_scalar(i)));
119		}
120	!	if (this->input_type == "prior") {
121	!	(*(this->priors[i]))[0] =
122	!	rnorm(this->get_expected(i),
123	!	fims_math::exp(log_sd.get_force_scalar(i)));
124		}
125		}
126		}
127		#endif
128		/* osa not working yet
129		if(osa_flag){//data observation type implements osa residuals
130		//code for osa cdf method
131		this->lpdf_vec[i] = this->keep.cdf_lower[i] * log(
132		pnorm(this->observed_values[i], this->get_expected(i), sd[i]) );
133		this->lpdf_vec[i] = this->keep.cdf_upper[i] * log( 1.0 -
134		pnorm(this->observed_values[i], this->get_expected(i), sd[i]) );
135		} */
136		}
137		#ifdef TMB_MODEL
138	614x	vector<Type> normal_observed_values = this->observed_values.to_tmb();
139		#endif
140	614x	return (this->lpdf);
141		}
142		};
143
144		} // namespace fims_distributions
145		#endif

1		/**
2		* @file interface.hpp
3		* @brief An interface to the modeling platforms, e.g., TMB.
4		* @copyright This file is part of the NOAA, National Marine Fisheries Service
5		* Fisheries Integrated Modeling System project. See LICENSE in the source
6		* folder for reuse information.
7		*/
8
9		#ifndef FIMS_INTERFACE_HPP
10		#define FIMS_INTERFACE_HPP
11
12		/*
13		* @brief Interface file. Uses pre-processing macros
14		* to interface with multiple modeling platforms.
15		*/
16
17		// traits for interfacing with TMB
18
19		#ifdef TMB_MODEL
20		// use isnan macro in math.h instead of TMB's isnan for fixing the r-cmd-check
21		// issue
22		#include <math.h>
23
24		#include <TMB.hpp>
25
26		// define REPORT, ADREPORT, and SIMULATE
27		#define FIMS_REPORT_F(name, F) \
28		if (isDouble<Type>::value && \
29		F->current_parallel_region < static_cast<Type>(0)) { \
30		Rf_defineVar(Rf_install(#name), PROTECT(asSEXP(name)), F->report); \
31		UNPROTECT(1); \
32		}
33
34		#define FIMS_REPORT_F_(name, obj, F) \
35		if (isDouble<Type>::value && \
36		F->current_parallel_region < static_cast<Type>(0)) { \
37		Rf_defineVar(Rf_install(name), PROTECT(asSEXP(obj)), F->report); \
38		UNPROTECT(1); \
39		}
40
41		#define ADREPORT_F(name, F) F->reportvector.push(name, #name);
42
43		template <typename Type>
44	16320x	vector<Type> ADREPORTvector(vector<vector<Type> > x) {
45	16320x	int outer_dim = x.size();
46	16320x	int dim = 0;
47	41760x	for (int i = 0; i < outer_dim; i++) {
48	25440x	dim += x(i).size();
49		}
50	16320x	vector<Type> res(dim);
51	16320x	int idx = 0;
52	41760x	for (int i = 0; i < outer_dim; i++) {
53	25440x	int inner_dim = x(i).size();
54	6019800x	for (int j = 0; j < inner_dim; j++) {
55	5994360x	res(idx) = x(i)(j);
56	5994360x	idx += 1;
57		}
58		}
59	16320x	return res;
60		}
61
62		#define FIMS_SIMULATE_F(F) if (isDouble<Type>::value && F->do_simulate)
63
64		#endif /* TMB_MODEL */
65
66		#ifndef TMB_MODEL
67		/**
68		* @brief TMB macro that simulates data.
69		*/
70		#define FIMS_SIMULATE_F(F)
71		/**
72		* @brief TMB macro that reports variables.
73		*/
74		#define FIMS_REPORT_F(name, F)
75		/**
76		* @brief TMB macro that reports variables and uncertainties.
77		*/
78		#define ADREPORT_F(name, F)
79		#endif
80
81		#endif /* FIMS_INTERFACE_HPP */

1		/**
2		* @file rcpp_interface.hpp
3		* @brief The Rcpp interface to declare things.
4		* @copyright This file is part of the NOAA, National Marine Fisheries Service
5		* Fisheries Integrated Modeling System project. See LICENSE in the source
6		* folder for reuse information.
7		*/
8		#ifndef FIMS_INTERFACE_RCPP_INTERFACE_HPP
9		#define FIMS_INTERFACE_RCPP_INTERFACE_HPP
10		#include "../../common/model.hpp"
11		#include "../../utilities/fims_json.hpp"
12		#include "rcpp_objects/rcpp_data.hpp"
13		#include "rcpp_objects/rcpp_distribution.hpp"
14		#include "rcpp_objects/rcpp_fleet.hpp"
15		#include "rcpp_objects/rcpp_growth.hpp"
16		#include "rcpp_objects/rcpp_interface_base.hpp"
17		#include "rcpp_objects/rcpp_maturity.hpp"
18		#include "rcpp_objects/rcpp_models.hpp"
19		#include "rcpp_objects/rcpp_natural_mortality.hpp"
20		#include "rcpp_objects/rcpp_population.hpp"
21		#include "rcpp_objects/rcpp_recruitment.hpp"
22		#include "rcpp_objects/rcpp_selectivity.hpp"
23
24		/**
25		* Initializes the logging system, setting all signal handling.
26		*/
27	42x	void init_logging() {
28	42x	std::signal(SIGSEGV, &fims::WriteAtExit);
29	42x	std::signal(SIGINT, &fims::WriteAtExit);
30	42x	std::signal(SIGABRT, &fims::WriteAtExit);
31	42x	std::signal(SIGFPE, &fims::WriteAtExit);
32	42x	std::signal(SIGILL, &fims::WriteAtExit);
33	42x	std::signal(SIGTERM, &fims::WriteAtExit);
34		}
35
36		/**
37		* @brief Initialize and construct the FIMS model using TMB.
38		*
39		* @details
40		* This function sets up the core C++ objects required for building the
41		* objective function with TMB before optimizing a FIMS model. The main steps
42		* of the function are as follows:
43		* - The logging system is initialized and any existing model structures are
44		* cleared, ensuring a clean slate for a new model.
45		* - It resets and prepares the main model information objects
46		* (fims_info::Information singletons), ensuring all internal data and
47		* settings are cleared and ready for a new model run. This step is essential
48		* for both initializing the model structure and avoiding conflicts from
49		* previous runs.
50		* - It iterates over all registered FIMS interface objects and adds them to
51		* the TMB model context.
52		* - After all of the objects are registered, it calls
53		* fims_info::Information::CreateModel() and
54		* fims_info::Information::CheckModel() on the base fims_info::Information
55		* object.
56		* - It instantiates the singleton fims_model::Model object which represents
57		* the constructed TMB model.
58		*
59		* Typically the average user does not interact with this function because it
60		* is called within <a href =
61		* "https://noaa-fims.github.io/FIMS/reference/initialize_fims.html">`initialize_fims`</a>.
62		*
63		* @see init_logging()
64		* @see fims_info::Information::Clear()
65		* @see fims_info::Information::CreateModel()
66		* @see fims_info::Information::CheckModel()
67		* @see fims_info::Information::GetInstance()
68		* @see <a href =
69		* "https://noaa-fims.github.io/FIMS/reference/initialize_fims.html"
70		* target="_blank">`initialize_fims()`</a>
71		* @return A boolean is returned, where true indicates that the model was
72		* successfully created.
73		*/
74	42x	bool CreateTMBModel() {
75	42x	init_logging();
76
77		// clear first
78		// base model
79		std::shared_ptr<fims_info::Information<TMB_FIMS_REAL_TYPE>> info0 =
80	42x	fims_info::Information<TMB_FIMS_REAL_TYPE>::GetInstance();
81	42x	info0->Clear();
82
83		std::shared_ptr<fims_info::Information<TMBAD_FIMS_TYPE>> info =
84	42x	fims_info::Information<TMBAD_FIMS_TYPE>::GetInstance();
85	42x	info->Clear();
86
87	42x	FIMS_INFO_LOG(
88		"Adding FIMS objects to TMB, " +
89		fims::to_string(FIMSRcppInterfaceBase::fims_interface_objects.size()) +
90		" objects");
91	719x	for (size_t i = 0; i < FIMSRcppInterfaceBase::fims_interface_objects.size();
92		i++) {
93	679x	FIMSRcppInterfaceBase::fims_interface_objects[i]->add_to_fims_tmb();
94		}
95
96		// base model
97	40x	info0->CreateModel();
98	40x	info0->CheckModel();
99
100	40x	info->CreateModel();
101
102		// instantiate the model? TODO: Ask Matthew what this does
103		std::shared_ptr<fims_model::Model<TMB_FIMS_REAL_TYPE>> m0 =
104	40x	fims_model::Model<TMB_FIMS_REAL_TYPE>::GetInstance();
105
106	40x	return true;
107		}
108
109		/* Dictionary block for shared documentation.
110		[details_set_x_parameters]
111		Updates the internal parameter values for the model base of type
112		TMB_FIMS_REAL_TYPE. It is typically called before finalize() or
113		@ref CatchAtAgeInterface::to_json "`get_output()`" to ensure the correct
114		values are used because TMB doesn't always keep the updated parameters in
115		the "double" version of the tape. So we need to update those first.
116		\n\n
117		Usage example in R:
118		\code{.R}
119		set_fixed_parameters(c(1, 2, 3))
120		set_random_parameters(c(1, 2, 3))
121		catch_at_age$get_output()
122		\endcode
123		[details_set_x_parameters]
124		*/
125		/* Dictionary block for shared documentation.
126		[param_par]
127		@param par A vector of parameter values.
128		[param_par]
129		*/
130
131		/**
132		* @brief Update fixed parameters in the tape, so the output is correct.
133		* @details @snippet{doc} this details_set_x_parameters
134		* @snippet{doc} this param_par
135		* @see set_random_parameters()
136		*/
137	19x	void set_fixed_parameters(Rcpp::NumericVector par) {
138		// base model
139		std::shared_ptr<fims_info::Information<TMB_FIMS_REAL_TYPE>> info0 =
140	19x	fims_info::Information<TMB_FIMS_REAL_TYPE>::GetInstance();
141
142	939x	for (size_t i = 0; i < info0->fixed_effects_parameters.size(); i++) {
143	920x	*info0->fixed_effects_parameters[i] = par[i];
144		}
145		}
146
147		/**
148		* @brief Gets the fixed parameters vector object.
149		*
150		* @return Rcpp::NumericVector
151		*/
152	36x	Rcpp::NumericVector get_fixed_parameters_vector() {
153		// base model
154		std::shared_ptr<fims_info::Information<TMB_FIMS_REAL_TYPE>> info0 =
155	36x	fims_info::Information<TMB_FIMS_REAL_TYPE>::GetInstance();
156
157	36x	Rcpp::NumericVector p;
158
159	1506x	for (size_t i = 0; i < info0->fixed_effects_parameters.size(); i++) {
160	1470x	p.push_back(*info0->fixed_effects_parameters[i]);
161		}
162
163	72x	return p;
164		}
165
166		/**
167		* @brief Update random effect parameters in the tape, so the output is correct.
168		* @details @snippet{doc} this details_set_x_parameters
169		* @snippet{doc} this param_par
170		* @see set_fixed_parameters()
171		*/
172	!	void set_random_parameters(Rcpp::NumericVector par) {
173		// base model
174		std::shared_ptr<fims_info::Information<TMB_FIMS_REAL_TYPE>> info0 =
175	!	fims_info::Information<TMB_FIMS_REAL_TYPE>::GetInstance();
176
177	!	for (size_t i = 0; i < info0->random_effects_parameters.size(); i++) {
178	!	*info0->random_effects_parameters[i] = par[i];
179		}
180		}
181
182		/**
183		* @brief Gets the random parameters vector object.
184		*
185		* @return Rcpp::NumericVector
186		*/
187	36x	Rcpp::NumericVector get_random_parameters_vector() {
188		// base model
189		std::shared_ptr<fims_info::Information<TMB_FIMS_REAL_TYPE>> d0 =
190	36x	fims_info::Information<TMB_FIMS_REAL_TYPE>::GetInstance();
191
192	36x	Rcpp::NumericVector p;
193
194	481x	for (size_t i = 0; i < d0->random_effects_parameters.size(); i++) {
195	445x	p.push_back(*d0->random_effects_parameters[i]);
196		}
197
198	72x	return p;
199		}
200
201		/**
202		* @brief Gets the parameter names object.
203		*
204		* @param pars
205		* @return Rcpp::List
206		*/
207	27x	Rcpp::List get_parameter_names(Rcpp::List pars) {
208		// base model
209		std::shared_ptr<fims_info::Information<TMB_FIMS_REAL_TYPE>> d0 =
210	27x	fims_info::Information<TMB_FIMS_REAL_TYPE>::GetInstance();
211
212	54x	pars.attr("names") = d0->parameter_names;
213
214	54x	return pars;
215		}
216
217		/**
218		* @brief Gets the random effects names object.
219		*
220		* @param pars
221		* @return Rcpp::List
222		*/
223	13x	Rcpp::List get_random_names(Rcpp::List pars) {
224		// base model
225		std::shared_ptr<fims_info::Information<TMB_FIMS_REAL_TYPE>> d0 =
226	13x	fims_info::Information<TMB_FIMS_REAL_TYPE>::GetInstance();
227
228	26x	pars.attr("names") = d0->random_effects_names;
229
230	26x	return pars;
231		}
232
233		/**
234		* @brief Clears the internal objects.
235		*
236		* @tparam Type
237		*/
238		template <typename Type>
239	600x	void clear_internal() {
240	600x	std::shared_ptr<fims_info::Information<Type>> d0 =
241		fims_info::Information<Type>::GetInstance();
242	600x	d0->Clear();
243		}
244
245		/**
246		* @brief Clears the vector of independent variables.
247		*/
248	150x	void clear() {
249	300x	FIMS_INFO_LOG("Clearing FIMS objects from interface stack");
250		// rcpp_interface_base.hpp
251	150x	FIMSRcppInterfaceBase::fims_interface_objects.clear();
252
253		// Parameter and ParameterVector
254	150x	Parameter::id_g = 1;
255	150x	ParameterVector::id_g = 1;
256		// rcpp_data.hpp
257	150x	DataInterfaceBase::id_g = 1;
258	150x	DataInterfaceBase::live_objects.clear();
259
260	150x	AgeCompDataInterface::id_g = 1;
261	150x	AgeCompDataInterface::live_objects.clear();
262
263	150x	LengthCompDataInterface::id_g = 1;
264	150x	LengthCompDataInterface::live_objects.clear();
265
266	150x	LandingsDataInterface::id_g = 1;
267	150x	LandingsDataInterface::live_objects.clear();
268
269	150x	IndexDataInterface::id_g = 1;
270	150x	IndexDataInterface::live_objects.clear();
271
272		// rcpp_fleets.hpp
273	150x	FleetInterfaceBase::id_g = 1;
274	150x	FleetInterfaceBase::live_objects.clear();
275
276	150x	FleetInterface::id_g = 1;
277	150x	FleetInterface::live_objects.clear();
278
279		// rcpp_growth.hpp
280	150x	GrowthInterfaceBase::id_g = 1;
281	150x	GrowthInterfaceBase::live_objects.clear();
282
283	150x	EWAAGrowthInterface::id_g = 1;
284	150x	EWAAGrowthInterface::live_objects.clear();
285
286		// rcpp_maturity.hpp
287	150x	MaturityInterfaceBase::id_g = 1;
288	150x	MaturityInterfaceBase::live_objects.clear();
289
290	150x	LogisticMaturityInterface::id_g = 1;
291	150x	LogisticMaturityInterface::live_objects.clear();
292
293		// rcpp_population.hpp
294	150x	PopulationInterfaceBase::id_g = 1;
295	150x	PopulationInterfaceBase::live_objects.clear();
296
297	150x	PopulationInterface::id_g = 1;
298	150x	PopulationInterface::live_objects.clear();
299
300		// rcpp_recruitment.hpp
301	150x	RecruitmentInterfaceBase::id_g = 1;
302	150x	RecruitmentInterfaceBase::live_objects.clear();
303
304	150x	BevertonHoltRecruitmentInterface::id_g = 1;
305	150x	BevertonHoltRecruitmentInterface::live_objects.clear();
306
307		// rcpp_selectivity.hpp
308	150x	SelectivityInterfaceBase::id_g = 1;
309	150x	SelectivityInterfaceBase::live_objects.clear();
310
311	150x	LogisticSelectivityInterface::id_g = 1;
312	150x	LogisticSelectivityInterface::live_objects.clear();
313
314	150x	DoubleLogisticSelectivityInterface::id_g = 1;
315	150x	DoubleLogisticSelectivityInterface::live_objects.clear();
316
317		// rcpp_distribution.hpp
318	150x	DistributionsInterfaceBase::id_g = 1;
319	150x	DistributionsInterfaceBase::live_objects.clear();
320
321	150x	DnormDistributionsInterface::id_g = 1;
322	150x	DnormDistributionsInterface::live_objects.clear();
323
324	150x	DlnormDistributionsInterface::id_g = 1;
325	150x	DlnormDistributionsInterface::live_objects.clear();
326
327	150x	DmultinomDistributionsInterface::id_g = 1;
328	150x	DmultinomDistributionsInterface::live_objects.clear();
329
330	150x	FisheryModelInterfaceBase::id_g = 1;
331	150x	FisheryModelInterfaceBase::live_objects.clear();
332
333	150x	clear_internal<TMB_FIMS_REAL_TYPE>();
334	150x	clear_internal<TMBAD_FIMS_TYPE>();
335
336	150x	fims::FIMSLog::fims_log->clear();
337		}
338
339		/**
340		* @brief Gets the log entries as a string in JSON format.
341		*/
342	!	std::string get_log() { return fims::FIMSLog::fims_log->get_log(); }
343
344		/**
345		* @brief Gets the error entries from the log as a string in JSON format.
346		*/
347	!	std::string get_log_errors() { return fims::FIMSLog::fims_log->get_errors(); }
348
349		/**
350		* @brief Gets the warning entries from the log as a string in JSON format.
351		*/
352	!	std::string get_log_warnings() {
353	!	return fims::FIMSLog::fims_log->get_warnings();
354		}
355
356		/**
357		* @brief Gets the info entries from the log as a string in JSON format.
358		*/
359	!	std::string get_log_info() { return fims::FIMSLog::fims_log->get_info(); }
360
361		/**
362		* @brief If true, writes the log on exit.
363		*/
364	!	void write_log(bool write) {
365	!	FIMS_INFO_LOG("Setting FIMS write log: " + fims::to_string(write));
366	!	fims::FIMSLog::fims_log->write_on_exit = write;
367		}
368
369		/**
370		* @brief Sets the path for the log file to be written to.
371		*/
372	!	void set_log_path(const std::string &path) {
373	!	FIMS_INFO_LOG("Setting FIMS log path: " + path);
374	!	fims::FIMSLog::fims_log->set_path(path);
375		}
376
377		/**
378		* @brief If true, throws a runtime exception when an error is logged.
379		*/
380	!	void set_log_throw_on_error(bool throw_on_error) {
381	!	fims::FIMSLog::fims_log->throw_on_error = throw_on_error;
382		}
383
384		/**
385		* @brief Adds an info entry to the log from the R environment.
386		*/
387	!	void log_info(std::string log_entry) {
388	!	fims::FIMSLog::fims_log->info_message(log_entry, -1, "R_env",
389		"R_script_entry");
390		}
391
392		/**
393		* @brief Adds a warning entry to the log from the R environment.
394		*/
395	!	void log_warning(std::string log_entry) {
396	!	fims::FIMSLog::fims_log->warning_message(log_entry, -1, "R_env",
397		"R_script_entry");
398		}
399
400		/**
401		* @brief Escapes quotations.
402		*
403		* @param input A string.
404		* @return std::string
405		*/
406	!	std::string escapeQuotes(const std::string &input) {
407	!	std::string result = input;
408	!	std::string search = "\"";
409	!	std::string replace = "\\\"";
410
411		// Find each occurrence of `"` and replace it with `\"`
412	!	size_t pos = result.find(search);
413	!	while (pos != std::string::npos) {
414	!	result.replace(pos, search.size(), replace);
415	!	pos = result.find(search,
416	!	pos + replace.size()); // Move past the replaced position
417		}
418	!	return result;
419		}
420
421		/**
422		* @brief Adds a error entry to the log from the R environment.
423		*/
424	!	void log_error(std::string log_entry) {
425	!	std::stringstream ss;
426	!	ss << "capture.output(traceback(4))";
427		SEXP expression, result;
428		ParseStatus status;
429
430	!	PROTECT(expression = R_ParseVector(Rf_mkString(ss.str().c_str()), 1, &status,
431		R_NilValue));
432	!	if (status != PARSE_OK) {
433	!	Rcpp::Rcout << "Error parsing expression" << std::endl;
434	!	UNPROTECT(1);
435		}
436	!	Rcpp::Rcout << "before call.";
437	!	PROTECT(result = Rf_eval(VECTOR_ELT(expression, 0), R_GlobalEnv));
438	!	Rcpp::Rcout << "after call.";
439	!	UNPROTECT(2);
440	!	std::stringstream ss_ret;
441	!	ss_ret << "traceback: ";
442	!	for (int j = 0; j < LENGTH(result); j++) {
443	!	std::string str(CHAR(STRING_ELT(result, j)));
444	!	ss_ret << escapeQuotes(str) << "\\n";
445		}
446
447		std::string ret =
448	!	ss_ret.str(); //"find error";//Rcpp::as<std::string>(result);
449
450	!	fims::FIMSLog::fims_log->error_message(log_entry, -1, "R_env", ret.c_str());
451		}
452		#endif // FIMS_INTERFACE_RCPP_INTERFACE_HPP

1		/**
2		* @file rcpp_data.hpp
3		* @brief The Rcpp interface to declare different types of data, e.g.,
4		* age-composition and index data. Allows for the use of methods::new() in R.
5		* @copyright This file is part of the NOAA, National Marine Fisheries Service
6		* Fisheries Integrated Modeling System project. See LICENSE in the source
7		* folder for reuse information.
8		*/
9		#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_DATA_HPP
10		#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_DATA_HPP
11
12		#include "../../../common/information.hpp"
13		#include "rcpp_interface_base.hpp"
14
15		/**
16		* @brief Rcpp interface that serves as the parent class for Rcpp data
17		* interfaces. This type should be inherited and not called from R directly.
18		*/
19		class DataInterfaceBase : public FIMSRcppInterfaceBase {
20		public:
21		/**
22		* @brief The vector of data that is being passed from R.
23		*/
24		Rcpp::NumericVector observed_data;
25		/**
26		* @brief The vector of uncertainty that is being passed from R.
27		*/
28		Rcpp::NumericVector uncertainty;
29		/**
30		* @brief The static id of the DataInterfaceBase object.
31		*/
32		static uint32_t id_g;
33		/**
34		* @brief The local id of the DataInterfaceBase object.
35		*
36		*/
37		uint32_t id;
38		/**
39		* @brief The map associating the IDs of DataInterfaceBase to the objects.
40		* This is a live object, which is an object that has been created and lives
41		* in memory.
42		*/
43		static std::map<uint32_t, std::shared_ptr<DataInterfaceBase>> live_objects;
44
45		/**
46		* @brief The constructor.
47		*/
48	197x	DataInterfaceBase() {
49	197x	this->id = DataInterfaceBase::id_g++;
50		/* Create instance of map: key is id and value is pointer to
51		DataInterfaceBase */
52		// DataInterfaceBase::live_objects[this->id] = this;
53		}
54
55		/**
56		* @brief Construct a new Data Interface Base object
57		*
58		* @param other
59		*/
60	197x	DataInterfaceBase(const DataInterfaceBase &other)
61	394x	: observed_data(other.observed_data),
62	197x	uncertainty(other.uncertainty),
63	394x	id(other.id) {}
64
65		/**
66		* @brief The destructor.
67		*/
68	394x	virtual ~DataInterfaceBase() {}
69
70		/**
71		* @brief Get the ID for the child data interface objects to inherit.
72		*/
73	!	virtual uint32_t get_id() { return this->id; }
74
75		/**
76		* @brief Adds the parameters to the TMB model.
77		*/
78	!	virtual bool add_to_fims_tmb() { return true; };
79		};
80		// static id of the DataInterfaceBase object
81		uint32_t DataInterfaceBase::id_g = 1;
82		// local id of the DataInterfaceBase object map relating the ID of the
83		// DataInterfaceBase to the DataInterfaceBase objects
84		std::map<uint32_t, std::shared_ptr<DataInterfaceBase>>
85		DataInterfaceBase::live_objects;
86
87		/**
88		* @brief The Rcpp interface for AgeComp to instantiate the object from R:
89		* acomp <- methods::new(AgeComp).
90		*/
91		class AgeCompDataInterface : public DataInterfaceBase {
92		public:
93		/**
94		* @brief The first dimension of the data, which relates to the number of age
95		* bins.
96		*/
97		fims_int amax = 0;
98		/**
99		* @brief The second dimension of the data, which relates to the number of
100		* time steps or years.
101		*/
102		fims_int ymax = 0;
103		/**
104		* @brief The vector of age-composition data that is being passed from R.
105		*/
106		RealVector age_comp_data;
107		/**
108		* @brief The vector of age-composition uncertainty that is being passed from
109		* R.
110		*/
111		RealVector uncertainty;
112
113		/**
114		* @brief The constructor.
115		*/
116	69x	AgeCompDataInterface(int ymax = 0, int amax = 0) : DataInterfaceBase() {
117	69x	this->amax = amax;
118	69x	this->ymax = ymax;
119	69x	this->age_comp_data.resize(amax * ymax);
120	69x	this->uncertainty.resize(amax * ymax);
121	69x	DataInterfaceBase::live_objects[this->id] =
122	138x	std::make_shared<AgeCompDataInterface>(*this);
123	69x	FIMSRcppInterfaceBase::fims_interface_objects.push_back(
124	69x	DataInterfaceBase::live_objects[this->id]);
125		}
126
127		/**
128		* @brief Construct a new Age Comp Data Interface object
129		*
130		* @param other
131		*/
132	69x	AgeCompDataInterface(const AgeCompDataInterface &other)
133	69x	: DataInterfaceBase(other),
134	69x	amax(other.amax),
135	69x	ymax(other.ymax),
136	69x	age_comp_data(other.age_comp_data),
137	138x	uncertainty(other.uncertainty) {}
138
139		/**
140		* @brief The destructor.
141		*/
142	414x	virtual ~AgeCompDataInterface() {}
143
144		/**
145		* @brief Gets the ID of the interface base object.
146		* @return The ID.
147		*/
148	62x	virtual uint32_t get_id() { return this->id; }
149
150		/**
151		* @brief Converts the data to json representation for the output.
152		* @return A string is returned specifying that the module relates to the
153		* data interface with age-composition data. It also returns the ID, the rank
154		* of 2, the dimensions by printing ymax and amax, followed by the data values
155		* themselves. This string is formatted for a json file.
156		*/
157	44x	virtual std::string to_json() {
158	44x	std::stringstream ss;
159
160	44x	ss << "{\n";
161	44x	ss << " \"name\": \"AgeComp\",\n";
162	44x	ss << " \"id\":" << this->id << ",\n";
163	44x	ss << " \"type\": \"data\",\n";
164	44x	ss << " \"dimensionality\": {\n";
165	44x	ss << " \"header\": [" << "\"n_ages\", \"n_years\"" << "],\n";
166	44x	ss << " \"dimensions\": [" << amax << ", " << ymax << "]\n},\n";
167	44x	ss << " \"value\": [";
168	16440x	for (size_t i = 0; i < age_comp_data.size() - 1; i++) {
169	16396x	ss << age_comp_data[i] << ", ";
170		}
171	44x	ss << age_comp_data[age_comp_data.size() - 1] << "],\n";
172	44x	ss << "\"uncertainty\":[ ";
173	16440x	for (size_t i = 0; i < uncertainty.size() - 1; i++) {
174	16396x	ss << uncertainty[i] << ", ";
175		}
176	44x	ss << uncertainty[uncertainty.size() - 1] << "]\n";
177	44x	ss << "}";
178	88x	return ss.str();
179		}
180
181		#ifdef TMB_MODEL
182
183		template <typename Type>
184	232x	bool add_to_fims_tmb_internal() {
185	232x	std::shared_ptr<fims_data_object::DataObject<Type>> age_comp_data =
186	232x	std::make_shared<fims_data_object::DataObject<Type>>(this->ymax,
187	232x	this->amax);
188
189	232x	age_comp_data->id = this->id;
190	7392x	for (int y = 0; y < ymax; y++) {
191	93080x	for (int a = 0; a < amax; a++) {
192	85920x	int i_age_year = y * amax + a;
193	85920x	age_comp_data->at(y, a) = this->age_comp_data[i_age_year];
194	85920x	age_comp_data->uncertainty[i_age_year] = this->uncertainty[i_age_year];
195		}
196		}
197
198	232x	std::shared_ptr<fims_info::Information<Type>> info =
199		fims_info::Information<Type>::GetInstance();
200
201	232x	info->data_objects[this->id] = age_comp_data;
202
203	232x	return true;
204		}
205
206		/**
207		* @brief Adds the parameters to the TMB model.
208		* @return A boolean of true.
209		*/
210	58x	virtual bool add_to_fims_tmb() {
211	58x	this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
212	58x	this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
213
214	58x	return true;
215		}
216
217		#endif
218		};
219
220		/**
221		* @brief The Rcpp interface for LengthComp to instantiate the object from R:
222		* lcomp <- methods::new(LengthComp).
223		*/
224		class LengthCompDataInterface : public DataInterfaceBase {
225		public:
226		/**
227		* @brief The first dimension of the data, which relates to the number of
228		* length bins.
229		*/
230		fims_int lmax = 0;
231		/**
232		* @brief The second dimension of the data, which relates to the number of
233		* time steps or years.
234		*/
235		fims_int ymax = 0;
236		/**
237		* @brief The vector of length-composition data that is being passed from R.
238		*/
239		RealVector length_comp_data;
240		/**
241		* @brief The vector of length-composition uncertainty that is being passed
242		* from R.
243		*/
244		RealVector uncertainty;
245
246		/**
247		* @brief The constructor.
248		*/
249	57x	LengthCompDataInterface(int ymax = 0, int lmax = 0) : DataInterfaceBase() {
250	57x	this->lmax = lmax;
251	57x	this->ymax = ymax;
252	57x	this->length_comp_data.resize(lmax * ymax);
253	57x	this->uncertainty.resize(lmax * ymax);
254	57x	DataInterfaceBase::live_objects[this->id] =
255	114x	std::make_shared<LengthCompDataInterface>(*this);
256	57x	FIMSRcppInterfaceBase::fims_interface_objects.push_back(
257	57x	DataInterfaceBase::live_objects[this->id]);
258		}
259
260		/**
261		* @brief Construct a new Length Comp Data Interface object
262		*
263		* @param other
264		*/
265	57x	LengthCompDataInterface(const LengthCompDataInterface &other)
266	57x	: DataInterfaceBase(other),
267	57x	lmax(other.lmax),
268	57x	ymax(other.ymax),
269	57x	length_comp_data(other.length_comp_data),
270	114x	uncertainty(other.uncertainty) {}
271
272		/**
273		* @brief The destructor.
274		*/
275	342x	virtual ~LengthCompDataInterface() {}
276
277		/**
278		* @brief Gets the ID of the interface base object.
279		* @return The ID.
280		*/
281	56x	virtual uint32_t get_id() { return this->id; }
282
283		/**
284		* @brief Converts the data to json representation for the output.
285		* @return A string is returned specifying that the module relates to the
286		* data interface with length-composition data. It also returns the ID, the
287		* rank of 2, the dimensions by printing ymax and lmax, followed by the data
288		* values themselves. This string is formatted for a json file.
289		*/
290	38x	virtual std::string to_json() {
291	38x	std::stringstream ss;
292
293	38x	ss << "{\n";
294	38x	ss << " \"name\": \"LengthComp\",\n";
295	38x	ss << " \"id\":" << this->id << ",\n";
296	38x	ss << " \"type\": \"data\",\n";
297	38x	ss << " \"dimensionality\": {\n";
298	38x	ss << " \"header\": [" << "\"n_lengths\", \"n_years\"" << "],\n";
299	38x	ss << " \"dimensions\": [" << lmax << ", " << ymax << "]\n},\n";
300	38x	ss << " \"value\": [";
301	27370x	for (size_t i = 0; i < length_comp_data.size() - 1; i++) {
302	27332x	ss << length_comp_data[i] << ", ";
303		}
304	38x	ss << length_comp_data[length_comp_data.size() - 1] << "],\n";
305	38x	ss << "\"uncertainty\": [ ";
306	27370x	for (size_t i = 0; i < uncertainty.size() - 1; i++) {
307	27332x	ss << uncertainty[i] << ", ";
308		}
309	38x	ss << uncertainty[uncertainty.size() - 1] << "]\n";
310	38x	ss << "}";
311	76x	return ss.str();
312		}
313
314		#ifdef TMB_MODEL
315		template <typename Type>
316	208x	bool add_to_fims_tmb_internal() {
317	208x	std::shared_ptr<fims_data_object::DataObject<Type>> length_comp_data =
318	208x	std::make_shared<fims_data_object::DataObject<Type>>(this->ymax,
319	208x	this->lmax);
320	208x	length_comp_data->id = this->id;
321	6648x	for (int y = 0; y < ymax; y++) {
322	154560x	for (int l = 0; l < lmax; l++) {
323	148120x	int i_length_year = y * lmax + l;
324	148120x	length_comp_data->at(y, l) = this->length_comp_data[i_length_year];
325	148120x	length_comp_data->uncertainty[i_length_year] =
326		this->uncertainty[i_length_year];
327		}
328		}
329	208x	std::shared_ptr<fims_info::Information<Type>> info =
330		fims_info::Information<Type>::GetInstance();
331	208x	info->data_objects[this->id] = length_comp_data;
332	208x	return true;
333		}
334
335		/**
336		* @brief Adds the parameters to the TMB model.
337		* @return A boolean of true.
338		*/
339	52x	virtual bool add_to_fims_tmb() {
340	52x	this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
341	52x	this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
342
343	52x	return true;
344		}
345		#endif
346		};
347
348		/**
349		* @brief The Rcpp interface for Index to instantiate the object from R:
350		* fleet <- methods::new(Index).
351		*/
352		class IndexDataInterface : public DataInterfaceBase {
353		public:
354		/**
355		* @brief An integer that specifies the second dimension of the data.
356		*/
357		fims_int ymax = 0;
358		/**
359		* @brief The vector of index data that is being passed from R.
360		*/
361		RealVector index_data;
362		/**
363		* @brief The vector of index uncertainty that is being passed from
364		* R.
365		*/
366		RealVector uncertainty;
367
368		/**
369		* @brief The constructor.
370		*/
371	37x	IndexDataInterface(int ymax = 0) : DataInterfaceBase() {
372	37x	this->ymax = ymax;
373	37x	this->index_data.resize(ymax);
374	37x	this->uncertainty.resize(ymax);
375	37x	DataInterfaceBase::live_objects[this->id] =
376	74x	std::make_shared<IndexDataInterface>(*this);
377	37x	FIMSRcppInterfaceBase::fims_interface_objects.push_back(
378	37x	DataInterfaceBase::live_objects[this->id]);
379		}
380
381		/**
382		* @brief Construct a new Index Data Interface object
383		*
384		* @param other
385		*/
386	37x	IndexDataInterface(const IndexDataInterface &other)
387	37x	: DataInterfaceBase(other),
388	37x	ymax(other.ymax),
389	37x	index_data(other.index_data),
390	74x	uncertainty(other.uncertainty) {}
391
392		/**
393		* @brief The destructor.
394		*/
395	222x	virtual ~IndexDataInterface() {}
396
397		/**
398		* @brief Gets the ID of the interface base object.
399		* @return The ID.
400		*/
401	34x	virtual uint32_t get_id() { return this->id; }
402
403		/**
404		* @brief Converts the data to json representation for the output.
405		* @return A string is returned specifying that the module relates to the
406		* data interface with index data. It also returns the ID, the rank of 1, the
407		* dimensions by printing ymax, followed by the data values themselves. This
408		* string is formatted for a json file.
409		*/
410	24x	virtual std::string to_json() {
411	24x	std::stringstream ss;
412
413	24x	ss << "{\n";
414	24x	ss << " \"name\": \"Index\",\n";
415	24x	ss << " \"id\": " << this->id << ",\n";
416	24x	ss << " \"type\": \"data\",\n";
417	24x	ss << " \"dimensionality\": {\n";
418	24x	ss << " \"header\": [" << "\"n_years\"" << "],\n";
419	24x	ss << " \"dimensions\": [" << ymax << "]\n},\n";
420	24x	ss << " \"value\": [";
421	745x	for (size_t i = 0; i < index_data.size() - 1; i++) {
422	721x	ss << index_data[i] << ", ";
423		}
424	24x	ss << index_data[index_data.size() - 1] << "],\n";
425	24x	ss << "\"uncertainty\": [ ";
426	745x	for (size_t i = 0; i < uncertainty.size() - 1; i++) {
427	721x	ss << uncertainty[i] << ", ";
428		}
429	24x	ss << uncertainty[uncertainty.size() - 1] << "]\n";
430	24x	ss << "}";
431	48x	return ss.str();
432		}
433
434		#ifdef TMB_MODEL
435
436		template <typename Type>
437	124x	bool add_to_fims_tmb_internal() {
438	124x	std::shared_ptr<fims_data_object::DataObject<Type>> data =
439	124x	std::make_shared<fims_data_object::DataObject<Type>>(this->ymax);
440
441	124x	data->id = this->id;
442
443	3944x	for (int y = 0; y < ymax; y++) {
444	3820x	data->at(y) = this->index_data[y];
445	3820x	data->uncertainty[y] = this->uncertainty[y];
446		}
447
448	124x	std::shared_ptr<fims_info::Information<Type>> info =
449		fims_info::Information<Type>::GetInstance();
450
451	124x	info->data_objects[this->id] = data;
452	124x	return true;
453		}
454
455		/**
456		* @brief Adds the parameters to the TMB model.
457		* @return A boolean of true.
458		*/
459	31x	virtual bool add_to_fims_tmb() {
460	31x	this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
461	31x	this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
462
463	31x	return true;
464		}
465
466		#endif
467		};
468
469		/**
470		* @brief The Rcpp interface for Landings to instantiate the object from R:
471		* fleet <- methods::new(Landings).
472		*/
473		class LandingsDataInterface : public DataInterfaceBase {
474		public:
475		/**
476		* @brief An integer that specifies the second dimension of the data.
477		*/
478		fims_int ymax = 0;
479		/**
480		* @brief The vector of landings data that is being passed from R.
481		*/
482		RealVector landings_data;
483		/**
484		* @brief The vector of landings uncertainty that is being passed from
485		* R.
486		*/
487		RealVector uncertainty;
488
489		/**
490		* @brief The constructor.
491		*/
492	34x	LandingsDataInterface(int ymax = 0) : DataInterfaceBase() {
493	34x	this->ymax = ymax;
494	34x	this->landings_data.resize(ymax);
495	34x	this->uncertainty.resize(ymax);
496	34x	DataInterfaceBase::live_objects[this->id] =
497	68x	std::make_shared<LandingsDataInterface>(*this);
498	34x	FIMSRcppInterfaceBase::fims_interface_objects.push_back(
499	34x	DataInterfaceBase::live_objects[this->id]);
500		}
501
502		/**
503		* @brief Construct a new Landings Data Interface object
504		*
505		* @param other
506		*/
507	34x	LandingsDataInterface(const LandingsDataInterface &other)
508	34x	: DataInterfaceBase(other),
509	34x	ymax(other.ymax),
510	34x	landings_data(other.landings_data),
511	68x	uncertainty(other.uncertainty) {}
512
513		/**
514		* @brief The destructor.
515		*/
516	204x	virtual ~LandingsDataInterface() {}
517
518		/**
519		* @brief Gets the ID of the interface base object.
520		* @return The ID.
521		*/
522	33x	virtual uint32_t get_id() { return this->id; }
523
524		/**
525		* @brief Converts the data to json representation for the output.
526		* @return A string is returned specifying that the module relates to the
527		* data interface with landings data. It also returns the ID, the rank of 1,
528		* the dimensions by printing ymax, followed by the data values themselves.
529		* This string is formatted for a json file.
530		*/
531	24x	virtual std::string to_json() {
532	24x	std::stringstream ss;
533
534	24x	ss << "{\n";
535	24x	ss << " \"name\": \"Landings\",\n";
536	24x	ss << " \"id\": " << this->id << ",\n";
537	24x	ss << " \"type\": \"data\",\n";
538	24x	ss << " \"dimensionality\": {\n";
539	24x	ss << " \"header\": [" << "\"n_years\"" << "],\n";
540	24x	ss << " \"dimensions\": [" << ymax << "]\n},\n";
541	24x	ss << " \"value\": [";
542	745x	for (size_t i = 0; i < landings_data.size() - 1; i++) {
543	721x	ss << landings_data[i] << ", ";
544		}
545	24x	ss << landings_data[landings_data.size() - 1] << "],\n";
546	24x	ss << "\"uncertainty\": [ ";
547	745x	for (size_t i = 0; i < uncertainty.size() - 1; i++) {
548	721x	ss << uncertainty[i] << ", ";
549		}
550	24x	ss << uncertainty[uncertainty.size() - 1] << "]\n";
551	24x	ss << "}";
552	48x	return ss.str();
553		}
554
555		#ifdef TMB_MODEL
556
557		template <typename Type>
558	124x	bool add_to_fims_tmb_internal() {
559	124x	std::shared_ptr<fims_data_object::DataObject<Type>> data =
560	124x	std::make_shared<fims_data_object::DataObject<Type>>(this->ymax);
561
562	124x	data->id = this->id;
563
564	3944x	for (int y = 0; y < ymax; y++) {
565	3820x	data->at(y) = this->landings_data[y];
566	3820x	data->uncertainty[y] = this->uncertainty[y];
567		}
568
569	124x	std::shared_ptr<fims_info::Information<Type>> info =
570		fims_info::Information<Type>::GetInstance();
571
572	124x	info->data_objects[this->id] = data;
573	124x	return true;
574		}
575
576		/**
577		* @brief Adds the parameters to the TMB model.
578		* @return A boolean of true.
579		*/
580	31x	virtual bool add_to_fims_tmb() {
581	31x	this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
582	31x	this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
583
584	31x	return true;
585		}
586
587		#endif
588		};
589
590		#endif

1		/**
2		* @file rcpp_fleet.hpp
3		* @brief The Rcpp interface to declare fleets. Allows for the use of
4		* methods::new() in R.
5		* @copyright This file is part of the NOAA, National Marine Fisheries Service
6		* Fisheries Integrated Modeling System project. See LICENSE in the source
7		* folder for reuse information.
8		*/
9		#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_FLEET_HPP
10		#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_FLEET_HPP
11
12		#include "../../../common/def.hpp"
13		#include "../../../population_dynamics/fleet/fleet.hpp"
14		#include "rcpp_interface_base.hpp"
15
16		/**
17		* @brief Rcpp interface that serves as the parent class for Rcpp fleet
18		* interfaces. This type should be inherited and not called from R directly.
19		*/
20		class FleetInterfaceBase : public FIMSRcppInterfaceBase {
21		public:
22		/**
23		* @brief The static id of the FleetInterfaceBase object.
24		*/
25		static uint32_t id_g;
26		/**
27		* @brief The local id of the FleetInterfaceBase object.
28		*/
29		uint32_t id;
30		/**
31		* @brief The map associating the IDs of FleetInterfaceBase to the objects.
32		* This is a live object, which is an object that has been created and lives
33		* in memory.
34		*/
35		static std::map<uint32_t, std::shared_ptr<FleetInterfaceBase>> live_objects;
36
37		/**
38		* @brief The constructor.
39		*/
40	71x	FleetInterfaceBase() {
41	71x	this->id = FleetInterfaceBase::id_g++;
42		/* Create instance of map: key is id and value is pointer to
43		FleetInterfaceBase */
44		// FleetInterfaceBase::live_objects[this->id] = this;
45		}
46
47		/**
48		* @brief Construct a new Fleet Interface Base object
49		*
50		* @param other
51		*/
52	71x	FleetInterfaceBase(const FleetInterfaceBase &other) : id(other.id) {}
53
54		/**
55		* @brief The destructor.
56		*/
57	142x	virtual ~FleetInterfaceBase() {}
58
59		/**
60		* @brief Get the ID for the child fleet interface objects to inherit.
61		*/
62		virtual uint32_t get_id() = 0;
63		};
64		// static id of the FleetInterfaceBase object
65		uint32_t FleetInterfaceBase::id_g = 1;
66		// local id of the FleetInterfaceBase object map relating the ID of the
67		// FleetInterfaceBase to the FleetInterfaceBase objects
68		std::map<uint32_t, std::shared_ptr<FleetInterfaceBase>>
69		FleetInterfaceBase::live_objects;
70		/**
71		* @brief The Rcpp interface for Fleet to instantiate from R:
72		* fleet <- methods::new(Fleet)
73		*/
74		class FleetInterface : public FleetInterfaceBase {
75		/**
76		* @brief The ID of the observed age-composition data object.
77		*/
78		SharedInt interface_observed_agecomp_data_id_m = -999;
79		/**
80		* @brief The ID of the observed length-composition data object.
81		*/
82		SharedInt interface_observed_lengthcomp_data_id_m = -999;
83		/**
84		* @brief The ID of the observed index data object.
85		*/
86		SharedInt interface_observed_index_data_id_m = -999;
87		/**
88		* @brief The ID of the observed landings data object.
89		*/
90		SharedInt interface_observed_landings_data_id_m = -999;
91		/**
92		* @brief The ID of the selectivity object.
93		*/
94		SharedInt interface_selectivity_id_m = -999;
95
96		public:
97		/**
98		* @brief The name of the fleet.
99		*/
100		SharedString name = fims::to_string("NA");
101		/**
102		* @brief The number of age bins in the fleet data.
103		*/
104		SharedInt n_ages = 0;
105		/**
106		* @brief The number of length bins in the fleet data.
107		*/
108		SharedInt n_lengths = 0;
109		/**
110		* @brief The number of years in the fleet data.
111		*/
112		SharedInt n_years = 0;
113		/**
114		* @brief What units are the observed landings for this fleet measured in.
115		* Options are weight or numbers, default is weight.
116		*/
117		SharedString observed_landings_units = fims::to_string("weight");
118		/**
119		* @brief What units is the observed index of abundance for this fleet
120		* measured in. Options are weight or numbers, default is weight.
121		*/
122		SharedString observed_index_units = fims::to_string("weight");
123		/**
124		* @brief The natural log of the index of abundance scaling parameter
125		* for this fleet.
126		*/
127		ParameterVector log_q;
128		/**
129		* @brief The vector of the natural log of fishing mortality rates for this
130		* fleet.
131		*/
132		ParameterVector log_Fmort;
133		/**
134		* @brief The vector of natural log of the expected total landings for
135		* the fleet.
136		*/
137		ParameterVector log_landings_expected;
138		/**
139		* @brief The vector of natural log of the expected index of abundance
140		* for the fleet.
141		*/
142		ParameterVector log_index_expected;
143		/**
144		* @brief The vector of expected landings-at-age in numbers for the fleet.
145		*/
146		ParameterVector agecomp_expected;
147		/**
148		* @brief The vector of expected landings-at-length in numbers for the fleet.
149		*/
150		ParameterVector lengthcomp_expected;
151		/**
152		* @brief The vector of expected landings-at-age in numbers for the fleet.
153		*/
154		ParameterVector agecomp_proportion;
155		/**
156		* @brief The vector of expected landings-at-length in numbers for the fleet.
157		*/
158		ParameterVector lengthcomp_proportion;
159		/**
160		* @brief The vector of conversions to go from age to length, i.e., the
161		* age-to-length-conversion matrix.
162		*/
163		ParameterVector age_to_length_conversion;
164
165		// derived quantities
166		/**
167		* @brief Derived landings-at-age in numbers.
168		*/
169		Rcpp::NumericVector derived_landings_naa;
170		/**
171		* @brief Derived landings-at-length in numbers.
172		*/
173		Rcpp::NumericVector derived_landings_nal;
174		/**
175		* @brief Derived landings-at-age in weight (mt).
176		*/
177		Rcpp::NumericVector derived_landings_waa;
178		/**
179		* @brief Derived landings in observed units.
180		*/
181		Rcpp::NumericVector derived_landings_expected;
182		/**
183		* @brief Derived landings in weight.
184		*/
185		Rcpp::NumericVector derived_landings_w;
186		/**
187		* @brief Derived landings in numbers.
188		*/
189		Rcpp::NumericVector derived_landings_n;
190		/**
191		* @brief Derived landings-at-age in numbers.
192		*/
193		Rcpp::NumericVector derived_index_naa;
194		/**
195		* @brief Derived landings-at-length in numbers.
196		*/
197		Rcpp::NumericVector derived_index_nal;
198		/**
199		* @brief Derived landings-at-age in weight (mt).
200		*/
201		Rcpp::NumericVector derived_index_waa;
202		/**
203		* @brief Derived index in observed units.
204		*/
205		Rcpp::NumericVector derived_index_expected;
206		/**
207		* @brief Derived index in weight.
208		*/
209		Rcpp::NumericVector derived_index_w;
210		/**
211		* @brief Derived index in numbers.
212		*/
213		Rcpp::NumericVector derived_index_n;
214		/**
215		* @brief Derived age composition proportions.
216		*/
217		Rcpp::NumericVector derived_agecomp_proportion;
218		/**
219		* @brief Derived length composition proportions.
220		*/
221		Rcpp::NumericVector derived_lengthcomp_proportion;
222		/**
223		* @brief Derived age compositions.
224		*/
225		Rcpp::NumericVector derived_agecomp_expected;
226		/**
227		* @brief Derived length compositions.
228		*/
229		Rcpp::NumericVector derived_lengthcomp_expected;
230
231		/**
232		* @brief The constructor.
233		*/
234	71x	FleetInterface() : FleetInterfaceBase() {
235		std::shared_ptr<FleetInterface> fleet =
236	71x	std::make_shared<FleetInterface>(*this);
237	71x	FIMSRcppInterfaceBase::fims_interface_objects.push_back(fleet);
238		/* Create instance of map: key is id and value is pointer to
239		FleetInterfaceBase */
240	71x	FleetInterfaceBase::live_objects[this->id] = fleet;
241		}
242
243		/**
244		* @brief Construct a new Fleet Interface object
245		*
246		* @param other
247		*/
248	71x	FleetInterface(const FleetInterface &other)
249	71x	: FleetInterfaceBase(other),
250	71x	interface_observed_agecomp_data_id_m(
251	71x	other.interface_observed_agecomp_data_id_m),
252	71x	interface_observed_lengthcomp_data_id_m(
253	71x	other.interface_observed_lengthcomp_data_id_m),
254	71x	interface_observed_index_data_id_m(
255	71x	other.interface_observed_index_data_id_m),
256	71x	interface_observed_landings_data_id_m(
257	71x	other.interface_observed_landings_data_id_m),
258	71x	interface_selectivity_id_m(other.interface_selectivity_id_m),
259	71x	name(other.name),
260	71x	n_ages(other.n_ages),
261	71x	n_lengths(other.n_lengths),
262	71x	n_years(other.n_years),
263	71x	observed_landings_units(other.observed_landings_units),
264	71x	observed_index_units(other.observed_index_units),
265	71x	log_q(other.log_q),
266	71x	log_Fmort(other.log_Fmort),
267	71x	log_landings_expected(other.log_landings_expected),
268	71x	log_index_expected(other.log_index_expected),
269	71x	agecomp_expected(other.agecomp_expected),
270	71x	lengthcomp_expected(other.lengthcomp_expected),
271	71x	agecomp_proportion(other.agecomp_proportion),
272	71x	lengthcomp_proportion(other.lengthcomp_proportion),
273	71x	age_to_length_conversion(other.age_to_length_conversion),
274	71x	derived_landings_naa(other.derived_landings_naa),
275	71x	derived_landings_nal(other.derived_landings_nal),
276	71x	derived_landings_waa(other.derived_landings_waa),
277	71x	derived_landings_expected(other.derived_landings_expected),
278	71x	derived_landings_w(other.derived_landings_w),
279	71x	derived_landings_n(other.derived_landings_n),
280	71x	derived_index_naa(other.derived_index_naa),
281	71x	derived_index_nal(other.derived_index_nal),
282	71x	derived_index_waa(other.derived_index_waa),
283	71x	derived_index_expected(other.derived_index_expected),
284	71x	derived_index_w(other.derived_index_w),
285	71x	derived_index_n(other.derived_index_n),
286	71x	derived_agecomp_proportion(other.derived_agecomp_proportion),
287	71x	derived_lengthcomp_proportion(other.derived_lengthcomp_proportion),
288	71x	derived_agecomp_expected(other.derived_agecomp_expected),
289	142x	derived_lengthcomp_expected(other.derived_lengthcomp_expected) {}
290
291		/**
292		* @brief The destructor.
293		*/
294	426x	virtual ~FleetInterface() {}
295
296		/**
297		* @brief Gets the ID of the interface base object.
298		* @return The ID.
299		*/
300	206x	virtual uint32_t get_id() { return this->id; }
301
302		/**
303		* @brief Sets the name of the fleet.
304		* @param name The name to set.
305		*/
306	!	void SetName(const std::string &name) { this->name.set(name); }
307
308		/**
309		* @brief Gets the name of the fleet.
310		* @return The name.
311		*/
312	!	std::string GetName() const { return this->name.get(); }
313
314		/**
315		* @brief Set the unique ID for the observed age-composition data object.
316		* @param observed_agecomp_data_id Unique ID for the observed data object.
317		*/
318	64x	void SetObservedAgeCompDataID(int observed_agecomp_data_id) {
319	64x	interface_observed_agecomp_data_id_m.set(observed_agecomp_data_id);
320		}
321
322		/**
323		* @brief Set the unique ID for the observed length-composition data object.
324		* @param observed_lengthcomp_data_id Unique ID for the observed data object.
325		*/
326	57x	void SetObservedLengthCompDataID(int observed_lengthcomp_data_id) {
327	57x	interface_observed_lengthcomp_data_id_m.set(observed_lengthcomp_data_id);
328		}
329
330		/**
331		* @brief Set the unique ID for the observed index data object.
332		* @param observed_index_data_id Unique ID for the observed data object.
333		*/
334	35x	void SetObservedIndexDataID(int observed_index_data_id) {
335	35x	interface_observed_index_data_id_m.set(observed_index_data_id);
336		}
337
338		/**
339		* @brief Set the unique ID for the observed landings data object.
340		* @param observed_landings_data_id Unique ID for the observed data object.
341		*/
342	34x	void SetObservedLandingsDataID(int observed_landings_data_id) {
343	34x	interface_observed_landings_data_id_m.set(observed_landings_data_id);
344		}
345		/**
346		* @brief Set the unique ID for the selectivity object.
347		* @param selectivity_id Unique ID for the observed object.
348		*/
349	69x	void SetSelectivityID(int selectivity_id) {
350	69x	interface_selectivity_id_m.set(selectivity_id);
351		}
352
353		/**
354		* @brief Get the unique ID for the selectivity object.
355		*
356		* @return uint32_t
357		*/
358	48x	uint32_t GetSelectivityID() { return interface_selectivity_id_m.get(); }
359
360		/**
361		* @brief Get the unique ID for the observed age-composition data object.
362		*/
363	107x	int GetObservedAgeCompDataID() {
364	107x	return interface_observed_agecomp_data_id_m.get();
365		}
366
367		/**
368		* @brief Get the unique ID for the observed length-composition data
369		* object.
370		*/
371	100x	int GetObservedLengthCompDataID() {
372	100x	return interface_observed_lengthcomp_data_id_m.get();
373		}
374
375		/**
376		* @brief Get the unique id for the observed index data object.
377		*/
378	82x	int GetObservedIndexDataID() {
379	82x	return interface_observed_index_data_id_m.get();
380		}
381
382		/**
383		* @brief Get the unique id for the observed landings data object.
384		*/
385	79x	int GetObservedLandingsDataID() {
386	79x	return interface_observed_landings_data_id_m.get();
387		}
388		/**
389		* @brief Extracts the derived quantities from `Information` to the Rcpp
390		* object.
391		*/
392	24x	virtual void finalize() {
393	24x	if (this->finalized) {
394		// log warning that finalize has been called more than once.
395	1x	FIMS_WARNING_LOG("Fleet " + fims::to_string(this->id) +
396		" has been finalized already.");
397		}
398
399	24x	this->finalized = true; // indicate this has been called already
400
401		std::shared_ptr<fims_info::Information<double>> info =
402	24x	fims_info::Information<double>::GetInstance();
403
404	24x	fims_info::Information<double>::fleet_iterator it;
405
406	24x	it = info->fleets.find(this->id);
407
408	24x	if (it == info->fleets.end()) {
409	!	FIMS_WARNING_LOG("Fleet " + fims::to_string(this->id) +
410		" not found in Information.");
411	!	return;
412		} else {
413		std::shared_ptr<fims_popdy::Fleet<double>> fleet =
414	24x	std::dynamic_pointer_cast<fims_popdy::Fleet<double>>(it->second);
415
416	769x	for (size_t i = 0; i < this->log_Fmort.size(); i++) {
417	745x	if (this->log_Fmort[i].estimation_type_m.get() == "constant") {
418	85x	this->log_Fmort[i].final_value_m = this->log_Fmort[i].initial_value_m;
419		} else {
420	660x	this->log_Fmort[i].final_value_m = fleet->log_Fmort[i];
421		}
422		}
423
424	48x	for (size_t i = 0; i < this->log_q.size(); i++) {
425	24x	if (this->log_q[i].estimation_type_m.get() == "constant") {
426	24x	this->log_q[i].final_value_m = this->log_q[i].initial_value_m;
427		} else {
428	!	this->log_q[i].final_value_m = fleet->log_q[i];
429		}
430		}
431
432	5268x	for (size_t i = 0; i < fleet->age_to_length_conversion.size(); i++) {
433	5244x	if (this->age_to_length_conversion[i].estimation_type_m.get() ==
434		"constant") {
435	5244x	this->age_to_length_conversion[i].final_value_m =
436	5244x	this->age_to_length_conversion[i].initial_value_m;
437		} else {
438	!	this->age_to_length_conversion[i].final_value_m =
439	!	fleet->age_to_length_conversion[i];
440		}
441		}
442		}
443		}
444
445		#ifdef TMB_MODEL
446
447		template <typename Type>
448	244x	bool add_to_fims_tmb_internal() {
449	244x	std::shared_ptr<fims_info::Information<Type>> info =
450		fims_info::Information<Type>::GetInstance();
451
452	244x	std::shared_ptr<fims_popdy::Fleet<Type>> fleet =
453		std::make_shared<fims_popdy::Fleet<Type>>();
454
455	244x	std::stringstream ss;
456
457		// set relative info
458	244x	fleet->id = this->id;
459	244x	fleet->n_ages = this->n_ages.get();
460	244x	fleet->n_lengths = this->n_lengths.get();
461	244x	fleet->n_years = this->n_years.get();
462	244x	fleet->observed_landings_units = this->observed_landings_units;
463	244x	fleet->observed_index_units = this->observed_index_units;
464
465	244x	fleet->fleet_observed_agecomp_data_id_m =
466	244x	interface_observed_agecomp_data_id_m.get();
467
468	244x	fleet->fleet_observed_lengthcomp_data_id_m =
469	244x	interface_observed_lengthcomp_data_id_m.get();
470
471	244x	fleet->fleet_observed_index_data_id_m =
472	244x	interface_observed_index_data_id_m.get();
473	244x	fleet->fleet_observed_landings_data_id_m =
474	244x	interface_observed_landings_data_id_m.get();
475
476	244x	fleet->fleet_selectivity_id_m = interface_selectivity_id_m.get();
477
478	244x	fleet->log_q.resize(this->log_q.size());
479	488x	for (size_t i = 0; i < this->log_q.size(); i++) {
480	244x	fleet->log_q[i] = this->log_q[i].initial_value_m;
481
482	244x	if (this->log_q[i].estimation_type_m.get() == "fixed_effects") {
483	116x	ss.str("");
484	116x	ss << "Fleet." << this->id << ".log_q." << this->log_q[i].id_m;
485	116x	info->RegisterParameterName(ss.str());
486	116x	info->RegisterParameter(fleet->log_q[i]);
487		}
488	244x	if (this->log_q[i].estimation_type_m.get() == "random_effects") {
489	!	ss.str("");
490	!	ss << "Fleet." << this->id << ".log_q." << this->log_q[i].id_m;
491	!	info->RegisterRandomEffectName(ss.str());
492	!	info->RegisterRandomEffect(fleet->log_q[i]);
493		}
494		}
495
496	488x	FIMS_INFO_LOG("adding Fleet fmort object to TMB");
497	244x	if (this->log_Fmort.size() != static_cast<size_t>(this->n_years.get())) {
498	2x	FIMS_ERROR_LOG("The size of `log_Fmort` does not match `n_years`: " +
499		fims::to_string(this->log_Fmort.size()) +
500		" != " + fims::to_string(this->n_years.get()));
501	2x	throw std::invalid_argument(
502		"Fleet log_Fmort size mismatch."
503		"Fleet log_Fmort is of size " +
504		fims::to_string(this->log_Fmort.size()) +
505		" and the number of years is " +
506		fims::to_string(this->n_years.get()));
507		}
508	240x	fleet->log_Fmort.resize(static_cast<size_t>(this->log_Fmort.size()));
509	7640x	for (size_t i = 0; i < log_Fmort.size(); i++) {
510	7400x	fleet->log_Fmort[i] = this->log_Fmort[i].initial_value_m;
511
512	7400x	if (this->log_Fmort[i].estimation_type_m.get() == "fixed_effects") {
513	3480x	ss.str("");
514	3480x	ss << "Fleet." << this->id << ".log_Fmort." << this->log_Fmort[i].id_m;
515	3480x	info->RegisterParameterName(ss.str());
516	3480x	info->RegisterParameter(fleet->log_Fmort[i]);
517		}
518	7400x	if (this->log_Fmort[i].estimation_type_m.get() == "random_effects") {
519	!	ss.str("");
520	!	ss << "Fleet." << this->id << ".log_Fmort." << this->log_Fmort[i].id_m;
521	!	info->RegisterRandomEffectName(ss.str());
522	!	info->RegisterRandomEffect(fleet->log_Fmort[i]);
523		}
524		}
525		// add to variable_map
526	240x	info->variable_map[this->log_Fmort.id_m] = &(fleet)->log_Fmort;
527
528	240x	if (this->n_lengths.get() > 0) {
529	200x	fleet->age_to_length_conversion.resize(
530		this->age_to_length_conversion.size());
531
532	200x	if (this->age_to_length_conversion.size() !=
533	200x	static_cast<size_t>(this->n_ages.get() * this->n_lengths.get())) {
534	!	FIMS_ERROR_LOG(
535		"age_to_length_conversion don't match, " +
536		fims::to_string(this->age_to_length_conversion.size()) + " != " +
537		fims::to_string((this->n_ages.get() * this->n_lengths.get())));
538		}
539
540	55400x	for (size_t i = 0; i < fleet->age_to_length_conversion.size(); i++) {
541	55200x	fleet->age_to_length_conversion[i] =
542	55200x	this->age_to_length_conversion[i].initial_value_m;
543	55200x	FIMS_INFO_LOG(" adding Fleet length object to TMB in loop " +
544		fims::to_string(i) + " of " +
545		fims::to_string(fleet->age_to_length_conversion.size()));
546
547	55200x	if (this->age_to_length_conversion[i].estimation_type_m.get() ==
548		"fixed_effects") {
549	!	ss.str("");
550	!	ss << "Fleet." << this->id << ".age_to_length_conversion."
551	!	<< this->age_to_length_conversion[i].id_m;
552	!	info->RegisterParameterName(ss.str());
553	!	info->RegisterParameter(fleet->age_to_length_conversion[i]);
554		}
555	55200x	if (this->age_to_length_conversion[i].estimation_type_m.get() ==
556		"random_effects") {
557	!	FIMS_ERROR_LOG(
558		"age_to_length_conversion cannot be set to random effects");
559		}
560		}
561
562	200x	info->variable_map[this->age_to_length_conversion.id_m] =
563	200x	&(fleet)->age_to_length_conversion;
564		}
565
566		// add to Information
567	240x	info->fleets[fleet->id] = fleet;
568	480x	FIMS_INFO_LOG("done adding Fleet object to TMB");
569	240x	return true;
570		}
571
572		/**
573		* @brief Adds the parameters to the TMB model.
574		* @return A boolean of true.
575		*/
576	62x	virtual bool add_to_fims_tmb() {
577	62x	this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
578	60x	this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
579
580	60x	return true;
581		}
582
583		#endif
584		};
585
586		#endif

1		/**
2		* @file rcpp_growth.hpp
3		* @brief The Rcpp interface to declare different types of growth, e.g.,
4		* empirical weight-at-age data. Allows for the use of methods::new() in R.
5		* @copyright This file is part of the NOAA, National Marine Fisheries Service
6		* Fisheries Integrated Modeling System project. See LICENSE in the source
7		* folder for reuse information.
8		*/
9		#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_GROWTH_HPP
10		#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_GROWTH_HPP
11
12		#include "../../../population_dynamics/growth/growth.hpp"
13		#include "rcpp_interface_base.hpp"
14
15		/**
16		* @brief Rcpp interface that serves as the parent class for Rcpp growth
17		* interfaces. This type should be inherited and not called from R directly.
18		*/
19		class GrowthInterfaceBase : public FIMSRcppInterfaceBase {
20		public:
21		/**
22		* @brief The static id of the GrowthInterfaceBase object.
23		*/
24		static uint32_t id_g;
25		/**
26		* @brief The local id of the GrowthInterfaceBase object.
27		*/
28		uint32_t id;
29		/**
30		* @brief The map associating the IDs of GrowthInterfaceBase to the objects.
31		* This is a live object, which is an object that has been created and lives
32		* in memory.
33		*/
34		static std::map<uint32_t, std::shared_ptr<GrowthInterfaceBase>> live_objects;
35
36		/**
37		* @brief The constructor.
38		*/
39	40x	GrowthInterfaceBase() {
40	40x	this->id = GrowthInterfaceBase::id_g++;
41		/* Create instance of map: key is id and value is pointer to
42		GrowthInterfaceBase */
43		// GrowthInterfaceBase::live_objects[this->id] =
44		// std::make_shared<GrowthInterfaceBase>(*this);
45		}
46
47		/**
48		* @brief Construct a new Growth Interface Base object
49		*
50		* @param other
51		*/
52	80x	GrowthInterfaceBase(const GrowthInterfaceBase &other) : id(other.id) {}
53
54		/**
55		* @brief The destructor.
56		*/
57	120x	virtual ~GrowthInterfaceBase() {}
58
59		/**
60		* @brief Get the ID for the child growth interface objects to inherit.
61		*/
62		virtual uint32_t get_id() = 0;
63
64		/**
65		* @brief A method for each child growth interface object to inherit so
66		* each growth option can have an evaluate() function.
67		*/
68		virtual double evaluate(double age) = 0;
69		};
70		// static id of the GrowthInterfaceBase object
71		uint32_t GrowthInterfaceBase::id_g = 1;
72		// local id of the GrowthInterfaceBase object map relating the ID of the
73		// GrowthInterfaceBase to the GrowthInterfaceBase objects
74		std::map<uint32_t, std::shared_ptr<GrowthInterfaceBase>>
75		GrowthInterfaceBase::live_objects;
76
77		/**
78		* @brief Rcpp interface for EWAAGrowth to instantiate the object from R:
79		* ewaa <- methods::new(EWAAGrowth). Where, EWAA stands for empirical weight at
80		* age and growth is not actually estimated.
81		*/
82		class EWAAGrowthInterface : public GrowthInterfaceBase {
83		public:
84		/**
85		* @brief Weights (mt) for each age class.
86		*/
87		RealVector weights;
88		/**
89		* @brief Ages (years) for each age class.
90		*/
91		RealVector ages;
92		/**
93		* @brief An integer specifying the number of years.
94		*
95		*/
96		SharedInt n_years;
97		/**
98		* @brief A map of empirical weight-at-age values allowing multiple modules to
99		* access and modify the weights without copying values between modules.
100		*/
101		std::shared_ptr<std::map<int, std::map<double, double>>> ewaa;
102		/**
103		* @brief Have weight and age vectors been set? The default is false.
104		*/
105		bool initialized = false;
106
107		/**
108		* @brief The constructor.
109		*/
110	40x	EWAAGrowthInterface() : GrowthInterfaceBase() {
111	40x	this->ewaa = std::make_shared<std::map<int, std::map<double, double>>>();
112	40x	GrowthInterfaceBase::live_objects[this->id] =
113	80x	std::make_shared<EWAAGrowthInterface>(*this);
114	40x	FIMSRcppInterfaceBase::fims_interface_objects.push_back(
115	80x	std::make_shared<EWAAGrowthInterface>(*this));
116		}
117
118		/**
119		* @brief Construct a new EWAAGrowthInterface object
120		*
121		* @param other
122		*/
123	80x	EWAAGrowthInterface(const EWAAGrowthInterface &other)
124	80x	: GrowthInterfaceBase(other), weights(other.weights), ages(other.ages),
125	80x	n_years(other.n_years), ewaa(other.ewaa),
126	80x	initialized(other.initialized) {}
127
128		/**
129		* @brief The destructor.
130		*/
131	320x	virtual ~EWAAGrowthInterface() {}
132
133		/**
134		* @brief Gets the ID of the interface base object.
135		* @return The ID.
136		*/
137	36x	virtual uint32_t get_id() { return this->id; }
138
139		/**
140		* @brief Create a map of input numeric vectors.
141		* @param weights Type vector of weights.
142		* @param ages Type vector of ages.
143		* @param n_years An integer specifying the number of years.
144		* @return std::map<T, T>.
145		*/
146	63x	inline std::map<int, std::map<double, double>> make_map(RealVector ages, RealVector weights,
147		SharedInt n_years) {
148	63x	std::map<int, std::map<double, double>> mymap;
149	63x	const size_t n_years_plus_one = static_cast<size_t>(n_years.get() + 1);
150
151		// Reject invalid year counts because map keys are expected to include
152		// at least one model year.
153	63x	if (n_years.get() < 1) {
154	!	Rcpp::stop("EWAA Error:: n_years must be at least 1");
155		}
156
157		// Reject empty vectors because we need at least one age-weight pair.
158		if (weights.size() == 0 \|\| ages.size() == 0) {
159	!	Rcpp::stop("EWAA Error:: ages and weights must have at least one value");
160		}
161
162		// Accept either:
163		// 1) one weight vector by age (shared across years), or
164		// 2) a full year-by-age matrix flattened as (n_years + 1) * n_ages.
165	77x	if ((weights.size() != ages.size() * n_years_plus_one) &&
166	14x	(weights.size() != ages.size())) {
167	2x	Rcpp::stop("weights size does not match ages size or ages size times "
168		"(n_years + 1), where the plus one is for the beginning "
169		"of the year after the terminal year spawning-biomass "
170		"calculations.");
171	61x	} else if (weights.size() == ages.size()) {
172		// One age-specific vector was provided, so replicate the same
173		// weight-at-age values for every year key (0 through n_years).
174	434x	for (size_t y = 0; y < n_years_plus_one; y++) {
175	5486x	for (size_t i = 0; i < ages.size(); i++) {
176	5064x	mymap[y][ages[i]] = weights[i];
177		}
178		}
179	49x	} else if (weights.size() == ages.size() * n_years_plus_one) {
180		// A flattened year-by-age matrix was provided, so map each block of
181		// n_ages values to the corresponding year key (0 through n_years).
182	1568x	for (size_t y = 0; y < n_years_plus_one; y++) {
183	19747x	for (size_t i = 0; i < ages.size(); i++) {
184	18228x	mymap[y][ages[i]] = weights[y * ages.size() + i];
185		}
186		}
187		}
188	61x	return mymap;
189		}
190
191		/**
192		* @brief Evaluate the growth using empirical weight at age.
193		* @param age The age at of the individual to evaluate weight.
194		* @details This can be called from R using ewaagrowth.evaluate(age).
195		*/
196	3x	virtual double evaluate(double age) {
197	3x	fims_popdy::EWAAGrowth<double> EWAAGrowth;
198
199		// Build the EWAA map once from R inputs the first time evaluate() is
200		// called.
201	3x	if (initialized == false) {
202	9x	EWAAGrowth.ewaa = make_map(this->ages, this->weights, this->n_years);
203	1x	initialized = true;
204		} else {
205		// Prevent re-initializing this object with a second evaluate() call.
206	!	Rcpp::stop(
207		"this empirical weight at age object is already initialized");
208		}
209	2x	return EWAAGrowth.evaluate(0, age);
210		}
211
212		/**
213		* @brief Converts the data to json representation for the output.
214		* @return A string is returned specifying that the module relates to the
215		* growth interface with empirical weight at age. It also returns the ID,
216		* the rank of 1, the dimensions, age bins, and the calculated values
217		* themselves. This string is formatted for a json file.
218		*/
219	24x	virtual std::string to_json() {
220	24x	std::stringstream ss;
221	24x	ss << "{\n";
222	24x	ss << " \"module_name\": \"Growth\",\n";
223	24x	ss << " \"module_type\": \"EWAA\",\n";
224	24x	ss << " \"module_id\":" << this->id << ",\n";
225	24x	ss << " \"parameters\": [\n{\n";
226	24x	ss << " \"name\": \"weight_at_age\",\n";
227	24x	ss << " \"id\": null,\n";
228	24x	ss << " \"type\": \"vector\",\n";
229	24x	ss << " \"dimensionality\": {\n";
230	24x	ss << " \"header\": [\"n_years+1\",\"n_ages\"],\n";
231	24x	ss << " \"dimensions\": [" << this->n_years.get() + 1 << "," << this->ages.size() << "]\n},\n";
232
233	24x	ss << " \"values\": [\n";
234	7128x	for (size_t i = 0; i < weights.size() - 1; i++) {
235	7104x	ss << "{\n";
236	7104x	ss << "\"id\": null,\n";
237	7104x	ss << "\"value\": " << weights[i] << ",\n";
238	7104x	ss << "\"estimated_value\": " << weights[i] << ",\n";
239	7104x	ss << "\"estimation_type\": \"constant\"\n";
240	7104x	ss << "},\n";
241		}
242	24x	ss << "{\n";
243	24x	ss << "\"id\": null,\n";
244	24x	ss << "\"value\": " << weights[weights.size() - 1] << ",\n";
245	24x	ss << "\"estimated_value\": " << weights[weights.size() - 1] << ",\n";
246	24x	ss << "\"estimation_type\": \"constant\"\n";
247	24x	ss << "}\n]\n";
248	24x	ss << "}\n]\n}\n";
249	48x	return ss.str();
250		}
251
252		#ifdef TMB_MODEL
253
254	120x	template <typename Type> bool add_to_fims_tmb_internal() {
255	120x	std::shared_ptr<fims_info::Information<Type>> info =
256		fims_info::Information<Type>::GetInstance();
257
258	120x	std::shared_ptr<fims_popdy::EWAAGrowth<Type>> ewaa_growth =
259		std::make_shared<fims_popdy::EWAAGrowth<Type>>();
260
261		// set relative info
262	120x	ewaa_growth->id = this->id;
263	120x	ewaa_growth->ewaa =
264	120x	make_map(this->ages, this->weights, this->n_years); // this->ewaa;
265		// add to Information
266	120x	info->growth_models[ewaa_growth->id] = ewaa_growth;
267
268	120x	return true;
269		}
270
271		/**
272		* @brief Adds the parameters to the TMB model.
273		* @return A boolean of true.
274		*/
275	30x	virtual bool add_to_fims_tmb() {
276	30x	this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
277	30x	this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
278
279	30x	return true;
280		}
281
282		#endif
283		};
284
285		#endif

1		/**
2		* @file rcpp_interface_base.hpp
3		* @brief The Rcpp interface to declare objects that are used ubiquitously
4		* throughout the Rcpp interface, e.g., Parameters and ParameterVectors.
5		* @copyright This file is part of the NOAA, National Marine Fisheries Service
6		* Fisheries Integrated Modeling System project. See LICENSE in the source
7		* folder for reuse information.
8		*/
9		#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_INTERFACE_BASE_HPP
10		#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_INTERFACE_BASE_HPP
11
12		#include <RcppCommon.h>
13		#include <map>
14		#include <vector>
15
16		#include "../../../common/def.hpp"
17		#include "../../../common/information.hpp"
18		#include "../../interface.hpp"
19		#include "rcpp_shared_primitive.hpp"
20		#include <limits>
21
22		#define RCPP_NO_SUGAR
23		#include <Rcpp.h>
24
25		/**
26		* @brief An Rcpp interface that defines the Parameter class.
27		*
28		* @details An Rcpp interface class that defines the interface between R and
29		* C++ for a parameter type.
30		*/
31		class Parameter {
32		public:
33		/**
34		* @brief The static ID of the Parameter object.
35		*/
36		static uint32_t id_g;
37		/**
38		* @brief The local ID of the Parameter object.
39		*/
40		uint32_t id_m;
41		/**
42		* @brief The initial value of the parameter.
43		*/
44		double initial_value_m = 0.0;
45		/**
46		* @brief The final value of the parameter.
47		*/
48		double final_value_m = 0.0;
49		/**
50		* @brief A string indicating the estimation type. Options are: constant,
51		* fixed_effects, or random_effects, where the default is constant.
52		*/
53		SharedString estimation_type_m = SharedString("constant");
54
55		/**
56		* @brief The constructor for initializing a parameter.
57		*/
58		Parameter(double value, std::string estimation_type)
59		: id_m(Parameter::id_g++),
60		initial_value_m(value),
61		estimation_type_m(estimation_type) {}
62
63		/**
64		* @brief The constructor for initializing a parameter.
65		*/
66	102708x	Parameter(const Parameter& other)
67	102708x	: id_m(other.id_m),
68	102708x	initial_value_m(other.initial_value_m),
69	102708x	final_value_m(other.final_value_m),
70	102708x	estimation_type_m(other.estimation_type_m) {}
71
72		/**
73		* @brief The constructor for initializing a parameter.
74		*/
75	38910x	Parameter& operator=(const Parameter& right) {
76		// Check for self-assignment!
77	38910x	if (this == &right) // Same object?
78	!	return this; // Yes, so skip assignment, and just return this.
79	38910x	this->id_m = right.id_m;
80	38910x	this->initial_value_m = right.initial_value_m;
81	38910x	this->estimation_type_m = right.estimation_type_m;
82	38910x	return *this;
83		}
84
85		/**
86		* @brief The constructor for initializing a parameter.
87		*/
88	3x	Parameter(double value) {
89	1x	initial_value_m = value;
90	1x	id_m = Parameter::id_g++;
91		}
92
93		/**
94		* @brief The constructor for initializing a parameter.
95		* @details Set value to 0 when there is no input value.
96		*/
97	255422x	Parameter() {
98	127711x	initial_value_m = 0;
99	127711x	id_m = Parameter::id_g++;
100		}
101		};
102		/**
103		* @brief The unique ID for the variable map that points to a fims::Vector.
104		*/
105		uint32_t Parameter::id_g = 0;
106
107		/**
108		* @brief Sanitize a double value by replacing NaN or Inf with -999.0.
109		*
110		* @param x The input double value.
111		* @return The sanitized double value.
112		*/
113	26330x	inline double sanitize_val(double x) {
114		if (std::isnan(x) \|\| std::isinf(x)) {
115	!	return -999.0;
116		}
117	26330x	return x;
118		}
119
120		/**
121		* @brief Output for std::ostream& for a parameter.
122		*
123		* @param out The stream.
124		* @param p A parameter.
125		* @return std::ostream&
126		*/
127	13165x	std::ostream& operator<<(std::ostream& out, const Parameter& p) {
128	13165x	out << "{\"id\": " << p.id_m
129	13165x	<< ",\n\"value\": " << sanitize_val(p.initial_value_m)
130	13165x	<< ",\n\"estimated_value\": " << sanitize_val(p.final_value_m);
131	13165x	out << ",\n\"estimation_type\": \"" << p.estimation_type_m << "\"\n}";
132
133	13165x	return out;
134		}
135
136		/**
137		* @brief An Rcpp interface class that defines the ParameterVector class.
138		*
139		* @details An Rcpp interface class that defines the interface between R and
140		* C++ for a parameter vector type.
141		*/
142		class ParameterVector {
143		public:
144		/**
145		* @brief The static ID of the Parameter object.
146		*/
147		static uint32_t id_g;
148		/**
149		* @brief Parameter storage.
150		*/
151		std::shared_ptr<std::vector<Parameter>> storage_m;
152		/**
153		* @brief The local ID of the Parameter object.
154		*/
155		uint32_t id_m;
156
157		/**
158		* @brief The constructor.
159		*/
160	1880x	ParameterVector() {
161	1880x	this->id_m = ParameterVector::id_g++;
162	1880x	this->storage_m = std::make_shared<std::vector<Parameter>>();
163	1880x	this->storage_m->resize(1); // push_back(Rcpp::wrap(p));
164		}
165
166		/**
167		* @brief The constructor.
168		*/
169	90624x	ParameterVector(const ParameterVector& other)
170	90624x	: storage_m(other.storage_m), id_m(other.id_m) {}
171
172		/**
173		* @brief The constructor.
174		*/
175	27x	ParameterVector(size_t size) {
176	27x	this->id_m = ParameterVector::id_g++;
177	27x	this->storage_m = std::make_shared<std::vector<Parameter>>();
178	27x	this->storage_m->resize(size);
179	288x	for (size_t i = 0; i < size; i++) {
180	261x	storage_m->at(i) = Parameter();
181		}
182		}
183
184		/**
185		* @brief The constructor for initializing a parameter vector.
186		* @param x A numeric vector.
187		* @param size The number of elements to copy over.
188		*/
189	2x	ParameterVector(Rcpp::NumericVector x, size_t size) {
190	2x	if (static_cast<size_t>(x.size()) != size) {
191		throw std::invalid_argument(
192		"Error in call to ParameterVector(Rcpp::NumericVector x, size_t "
193	1x	"size): x.size() != size argument.");
194		} else {
195	1x	this->id_m = ParameterVector::id_g++;
196	1x	this->storage_m = std::make_shared<std::vector<Parameter>>();
197		// Use std::min to avoid comparing signed and unsigned types
198	1x	size_t n = std::min(static_cast<size_t>(x.size()), size);
199	1x	this->storage_m->resize(n);
200	11x	for (size_t i = 0; i < n; i++) {
201	10x	storage_m->at(i).initial_value_m = x[i];
202		}
203		}
204		}
205
206		/**
207		* @brief The constructor for initializing a parameter vector.
208		* @param v A vector of doubles.
209		*/
210		ParameterVector(const fims::Vector<double>& v) {
211		this->id_m = ParameterVector::id_g++;
212		this->storage_m = std::make_shared<std::vector<Parameter>>();
213		this->storage_m->resize(v.size());
214		for (size_t i = 0; i < v.size(); i++) {
215		storage_m->at(i).initial_value_m = v[i];
216		}
217		}
218
219		/**
220		* @brief Destroy the Parameter Vector object.
221		*
222		*/
223	287312x	virtual ~ParameterVector() {}
224
225		/**
226		* @brief Gets the ID of the ParameterVector object.
227		*/
228	214x	virtual uint32_t get_id() { return this->id_m; }
229
230		/**
231		* @brief The accessor where the first index starts is zero.
232		* @param pos The position of the ParameterVector that you want returned.
233		*/
234	440689x	inline Parameter& operator[](size_t pos) { return this->storage_m->at(pos); }
235
236		/**
237		* @brief The accessor where the first index starts at one. This function is
238		* for calling accessing from R.
239		* @param pos The position of the ParameterVector that you want returned.
240		*/
241	2x	SEXP at(R_xlen_t pos) {
242	4x	if (static_cast<size_t>(pos) == 0 \|\|
243	2x	static_cast<size_t>(pos) > this->storage_m->size()) {
244	1x	throw std::invalid_argument("ParameterVector: Index out of range");
245		FIMS_ERROR_LOG(fims::to_string(pos) + "!<" +
246		fims::to_string(this->size()));
247		return NULL;
248		}
249	1x	return Rcpp::wrap(this->storage_m->at(pos - 1));
250		}
251
252		/**
253		* @brief An internal accessor for calling a position of a ParameterVector
254		* from R.
255		* @param pos An integer specifying the position of the ParameterVector
256		* you want returned. The first position is one and the last position is
257		* the same as the size of the ParameterVector.
258		*/
259	50957x	Parameter& get(size_t pos) {
260	50957x	if (pos >= this->storage_m->size()) {
261	1x	throw std::invalid_argument("ParameterVector: Index out of range");
262		}
263	50956x	return (this->storage_m->at(pos));
264		}
265
266		/**
267		* @brief An internal setter for setting a position of a ParameterVector
268		* from R.
269		* @param pos An integer specifying the position of the ParameterVector
270		* you want to set. The first position is one and the last position is the
271		* same as the size of the ParameterVector.
272		* @param p A numeric value specifying the value to set position `pos` to
273		* in the ParameterVector.
274		*/
275	37897x	void set(size_t pos, const Parameter& p) { this->storage_m->at(pos) = p; }
276
277		/**
278		* @brief Returns the size of a ParameterVector.
279		*/
280	146553x	size_t size() { return this->storage_m->size(); }
281
282		/**
283		* @brief Resizes a ParameterVector to the desired length.
284		* @param size An integer specifying the desired length for the
285		* ParameterVector to be resized to.
286		*/
287	1005x	void resize(size_t size) { this->storage_m->resize(size); }
288
289		/**
290		* @brief Sets all Parameters within a ParameterVector as estimable.
291		*
292		* @param estimable A boolean specifying if all Parameters within the
293		* ParameterVector should be estimated within the model. A value of true
294		* leads to all Parameters being estimated.
295		*/
296	141x	void set_all_estimable(bool estimable) {
297	23135x	for (size_t i = 0; i < this->storage_m->size(); i++) {
298	22994x	if (estimable) {
299	1908x	this->storage_m->at(i).estimation_type_m.set("fixed_effects");
300		} else {
301	67074x	this->storage_m->at(i).estimation_type_m.set("constant");
302		}
303		}
304		}
305
306		/**
307		* @brief Sets all Parameters within a ParameterVector as random effects.
308		*
309		* @param random A boolean specifying if all Parameters within the
310		* ParameterVector should be designated as random effects. A value of true
311		* leads to all Parameters being random effects.
312		*/
313	61x	void set_all_random(bool random) {
314	15909x	for (size_t i = 0; i < this->storage_m->size(); i++) {
315	15848x	if (random) {
316	348x	this->storage_m->at(i).estimation_type_m.set("random_effects");
317		} else {
318	47196x	this->storage_m->at(i).estimation_type_m.set("constant");
319		}
320		}
321		}
322
323		/**
324		* @brief Sets the value of all Parameters in the ParameterVector to the
325		* provided value.
326		*
327		* @param value A double specifying the value to set all Parameters to
328		* within the ParameterVector.
329		*/
330	1x	void fill(double value) {
331	11x	for (size_t i = 0; i < this->storage_m->size(); i++) {
332	10x	storage_m->at(i).initial_value_m = value;
333		}
334		}
335
336		/**
337		* @brief The printing methods for a ParameterVector.
338		*
339		*/
340	!	void show() {
341	!	Rcpp::Rcout << this->storage_m->data() << "\n";
342
343	!	for (size_t i = 0; i < this->storage_m->size(); i++) {
344	!	Rcpp::Rcout << storage_m->at(i) << " ";
345		}
346		}
347		};
348		uint32_t ParameterVector::id_g = 0;
349
350		/**
351		* @brief Output for std::ostream& for a ParameterVector.
352		*
353		* @param out The stream.
354		* @param v A ParameterVector.
355		* @return std::ostream&
356		*/
357	408x	std::ostream& operator<<(std::ostream& out, ParameterVector& v) {
358	408x	out << "[";
359	408x	size_t size = v.size();
360	13165x	for (size_t i = 0; i < size - 1; i++) {
361	12757x	out << v[i] << ", ";
362		}
363	408x	out << v[size - 1] << "]";
364	408x	return out;
365		}
366
367		/**
368		* @brief An Rcpp interface class that defines the RealVector class.
369		*
370		* @details An Rcpp interface class that defines the interface between R and
371		* C++ for a real vector type. Underlying values are held in a shared pointer
372		* and are carried over to any copies of this vector.
373		*/
374		class RealVector {
375		public:
376		/**
377		* @brief The static ID of the RealVector object.
378		*/
379		static uint32_t id_g;
380		/**
381		* @brief real storage.
382		*/
383		std::shared_ptr<std::vector<double>> storage_m;
384		/**
385		* @brief The local ID of the RealVector object.
386		*/
387		uint32_t id_m;
388
389		/**
390		* @brief The constructor.
391		*/
392	902x	RealVector() {
393	902x	this->id_m = RealVector::id_g++;
394	902x	this->storage_m = std::make_shared<std::vector<double>>();
395	902x	this->storage_m->resize(1);
396		}
397
398		/**
399		* @brief The constructor.
400		*/
401	80655x	RealVector(const RealVector& other)
402	80655x	: storage_m(other.storage_m), id_m(other.id_m) {}
403
404		/**
405		* @brief The constructor.
406		*/
407	74x	RealVector(size_t size) {
408	74x	this->id_m = RealVector::id_g++;
409	74x	this->storage_m = std::make_shared<std::vector<double>>();
410	74x	this->storage_m->resize(size);
411		}
412
413		/**
414		* @brief The constructor for initializing a real vector.
415		* @param x A numeric vector.
416		* @param size The number of elements to copy over.
417		*/
418	!	RealVector(Rcpp::NumericVector x, size_t size) {
419	!	this->id_m = RealVector::id_g++;
420	!	this->storage_m = std::make_shared<std::vector<double>>();
421	!	this->storage_m->assign(x.begin(), x.end());
422		}
423
424		/**
425		* @brief The constructor for initializing a real vector.
426		* @param v A vector of doubles.
427		*/
428		RealVector(const fims::Vector<double>& v) {
429		this->id_m = RealVector::id_g++;
430		this->storage_m = std::make_shared<std::vector<double>>();
431		this->storage_m->resize(v.size());
432		for (size_t i = 0; i < v.size(); i++) {
433		storage_m->at(i) = v[i];
434		}
435		}
436
437		/**
438		* @brief Destroy the real Vector object.
439		*
440		*/
441	322354x	virtual ~RealVector() {}
442
443		/**
444		* @brief
445		*
446		* @param v
447		* @return RealVector&
448		*/
449	82x	RealVector& operator=(const Rcpp::NumericVector& v) {
450	82x	this->storage_m->assign(v.begin(), v.end());
451	82x	return *this;
452		}
453
454		/**
455		* @brief Gets the ID of the RealVector object.
456		*/
457	!	virtual uint32_t get_id() { return this->id_m; }
458
459		/**
460		* @brief
461		*
462		* @param orig
463		*/
464	!	void fromRVector(const Rcpp::NumericVector& orig) {
465	!	this->storage_m->resize(orig.size());
466	!	for (size_t i = 0; i < this->storage_m->size(); i++) {
467	!	this->storage_m->at(i) = orig[i];
468		}
469		}
470
471		/**
472		* @brief
473		*
474		* @return Rcpp::NumericVector
475		*/
476	2x	Rcpp::NumericVector toRVector() {
477	2x	Rcpp::NumericVector ret(this->storage_m->size());
478	1052x	for (size_t i = 0; i < this->size(); i++) {
479	1050x	ret[i] = this->storage_m->at(i);
480		}
481
482	2x	return ret;
483		}
484
485		/**
486		* @brief The accessor where the first index starts is zero.
487		* @param pos The position of the RealVector that you want returned.
488		*/
489	579040x	inline double& operator[](size_t pos) { return this->storage_m->at(pos); }
490
491		/**
492		* @brief The accessor where the first index starts at one. This function is
493		* for calling accessing from R.
494		* @param pos The position of the ParameterVector that you want returned.
495		*/
496	!	SEXP at(R_xlen_t pos) {
497	!	if (static_cast<size_t>(pos) == 0 \|\|
498	!	static_cast<size_t>(pos) > this->storage_m->size()) {
499	!	throw std::invalid_argument("RealVector: Index out of range");
500		FIMS_ERROR_LOG(fims::to_string(pos) + "!<" +
501		fims::to_string(this->size()));
502		return NULL;
503		}
504	!	return Rcpp::wrap(this->storage_m->at(pos - 1));
505		}
506
507		/**
508		* @brief An internal accessor for calling a position of a RealVector
509		* from R.
510		* @param pos An integer specifying the position of the RealVector
511		* you want returned. The first position is one and the last position is
512		* the same as the size of the RealVector.
513		*/
514	2x	double& get(size_t pos) {
515	2x	if (pos >= this->storage_m->size()) {
516	!	throw std::invalid_argument("RealVector: Index out of range");
517		}
518	2x	return (this->storage_m->at(pos));
519		}
520
521		/**
522		* @brief An internal setter for setting a position of a RealVector
523		* from R.
524		* @param pos An integer specifying the position of the RealVector
525		* you want to set. The first position is one and the last position is the
526		* same as the size of the RealVector.
527		* @param p A numeric value specifying the value to set position `pos` to
528		* in the RealVector.
529		*/
530	79415x	void set(size_t pos, const double& p) { this->storage_m->at(pos) = p; }
531
532		/**
533		* @brief Returns the size of a RealVector.
534		*/
535	236599x	size_t size() { return this->storage_m->size(); }
536
537		/**
538		* @brief Resizes a RealVector to the desired length.
539		* @param size An integer specifying the desired length for the
540		* RealVector to be resized to.
541		*/
542	588x	void resize(size_t size) { this->storage_m->resize(size); }
543
544		/**
545		* @brief Sets the value of all elements in the RealVector to the
546		* provided value.
547		*
548		* @param value A double specifying the value to set all elements to
549		* within the RealVector.
550		*/
551		void fill(double value) {
552		for (size_t i = 0; i < this->storage_m->size(); i++) {
553		storage_m->at(i) = value;
554		}
555		}
556
557		/**
558		* @brief The printing methods for a RealVector.
559		*
560		*/
561	!	void show() {
562	!	Rcpp::Rcout << this->storage_m->data() << "\n";
563
564	!	for (size_t i = 0; i < this->storage_m->size(); i++) {
565	!	Rcpp::Rcout << storage_m->at(i) << " ";
566		}
567		}
568		};
569		uint32_t RealVector::id_g = 0;
570
571		/**
572		*@brief Base class for all interface objects.
573		*/
574		class FIMSRcppInterfaceBase {
575		public:
576		/**
577		* @brief Is the object already finalized? The default is false.
578		*/
579		bool finalized = false;
580		/**
581		* @brief FIMS interface object vectors.
582		*/
583		static std::vector<std::shared_ptr<FIMSRcppInterfaceBase>>
584		fims_interface_objects;
585
586		/**
587		* @brief A virtual method to inherit to add objects to the TMB model.
588		*/
589	!	virtual bool add_to_fims_tmb() {
590		Rcpp::Rcout << "fims_rcpp_interface_base::add_to_fims_tmb(): Not yet "
591	!	"implemented.\n";
592	!	return false;
593		}
594
595		/**
596		* @brief Extracts derived quantities back to the Rcpp interface object from
597		* the Information object.
598		*/
599	154x	virtual void finalize() {}
600
601		/**
602		* @brief Convert the data to json representation for the output.
603		*/
604	!	virtual std::string to_json() {
605	!	FIMS_WARNING_LOG("Method not yet defined.");
606	!	return "{\"name\": \"not yet implemented\"}";
607		}
608
609		/**
610		* @brief Report the parameter value as a string.
611		*
612		* @param value
613		* @return std::string
614		*/
615	94496x	std::string value_to_string(double value) {
616	94496x	std::stringstream ss;
617	94496x	if (value == std::numeric_limits<double>::infinity()) {
618	!	ss << "\"Infinity\"";
619	94496x	} else if (value == -std::numeric_limits<double>::infinity()) {
620	!	ss << "\"-Infinity\"";
621	94496x	} else if (value != value) {
622	1150x	ss << "-999";
623		} else {
624		// Set precision (R default is 16)
625	93346x	ss << std::fixed << std::setprecision(16) << value;
626		}
627	188992x	return ss.str();
628		}
629		/**
630		* @brief Make a string of dimensions for the model.
631		*/
632		std::string make_dimensions(uint32_t start, uint32_t end, uint32_t rep = 1) {
633		std::stringstream ss;
634
635		for (size_t i = 0; i < rep; i++) {
636		for (size_t j = start; j < end; j++) {
637		ss << j << ", ";
638		}
639		if (i < (rep - 1)) {
640		ss << end << ", ";
641		} else {
642		ss << end;
643		}
644		}
645		return ss.str();
646		}
647		};
648		std::vector<std::shared_ptr<FIMSRcppInterfaceBase>>
649		FIMSRcppInterfaceBase::fims_interface_objects;
650
651		#endif

1		/**
2		* @file rcpp_math.hpp
3		* @brief The Rcpp interface to declare different mathematical functions that
4		* are written in C++ but can be used within R.
5		* @copyright This file is part of the NOAA, National Marine Fisheries Service
6		* Fisheries Integrated Modeling System project. See LICENSE in the source
7		* folder for reuse information.
8		*/
9		#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_MATH_HPP
10		#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_MATH_HPP
11
12		#include "rcpp_interface_base.hpp"
13		#include "../../../common/fims_math.hpp"
14
15		/**
16		* @brief A rcpp interface to the logit function.
17		*
18		* @param a Lower bound of the logit function, typically 0.0.
19		* @param b Upper bound of the logit function, typically 1.0.
20		* @param x A single numeric value (double) to be transformed on the real line.
21		* @return A double in real space rather than the bounded space.
22		*/
23	5x	double logit_rcpp(double a, double b, double x) {
24	5x	return fims_math::logit<double>(a, b, x);
25		}
26
27		/**
28		* @brief A rcpp interface to the inverse-logit function.
29		*
30		* @param a Lower bound of the logit function, typically 0.0.
31		* @param b Upper bound of the logit function, typically 1.0.
32		* @param logit_x A single numeric value (double) in real space.
33		* @return A double in the bounded space rather than real space.
34		*/
35	5x	double inv_logit_rcpp(double a, double b, double logit_x) {
36	5x	return fims_math::inv_logit<double>(a, b, logit_x);
37		}
38
39		#endif

1		/**
2		* @file rcpp_maturity.hpp
3		* @brief The Rcpp interface to declare different maturity options, e.g.,
4		* logistic. Allows for the use of methods::new() in R.
5		* @copyright This file is part of the NOAA, National Marine Fisheries Service
6		* Fisheries Integrated Modeling System project. See LICENSE in the source
7		* folder for reuse information.
8		*/
9		#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_MATURITY_HPP
10		#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_MATURITY_HPP
11
12		#include "../../../population_dynamics/maturity/maturity.hpp"
13		#include "rcpp_interface_base.hpp"
14
15		/**
16		* @brief Rcpp interface that serves as the parent class for Rcpp maturity
17		* interfaces. This type should be inherited and not called from R directly.
18		*/
19		class MaturityInterfaceBase : public FIMSRcppInterfaceBase {
20		public:
21		/**
22		* @brief The static id of the MaturityInterfaceBase object.
23		*/
24		static uint32_t id_g;
25		/**
26		* @brief The local id of the MaturityInterfaceBase object.
27		*/
28		uint32_t id;
29		/**
30		* @brief The map associating the IDs of MaturityInterfaceBase to the objects.
31		* This is a live object, which is an object that has been created and lives
32		* in memory.
33		*/
34		static std::map<uint32_t, std::shared_ptr<MaturityInterfaceBase>>
35		live_objects;
36
37		/**
38		* @brief The constructor.
39		*/
40	36x	MaturityInterfaceBase() {
41	36x	this->id = MaturityInterfaceBase::id_g++;
42		/* Create instance of map: key is id and value is pointer to
43		MaturityInterfaceBase */
44		// MaturityInterfaceBase::live_objects[this->id] = this;
45		}
46
47		/**
48		* @brief Construct a new Maturity Interface Base object
49		*
50		* @param other
51		*/
52	36x	MaturityInterfaceBase(const MaturityInterfaceBase& other) : id(other.id) {}
53
54		/**
55		* @brief The destructor.
56		*/
57	72x	virtual ~MaturityInterfaceBase() {}
58
59		/**
60		* @brief Get the ID for the child maturity interface objects to inherit.
61		*/
62		virtual uint32_t get_id() = 0;
63
64		/**
65		* @brief A method for each child maturity interface object to inherit so
66		* each maturity option can have an evaluate() function.
67		*/
68		virtual double evaluate(double x) = 0;
69		};
70		// static id of the MaturityInterfaceBase object
71		uint32_t MaturityInterfaceBase::id_g = 1;
72		// local id of the MaturityInterfaceBase object map relating the ID of the
73		// MaturityInterfaceBase to the MaturityInterfaceBase objects
74		std::map<uint32_t, std::shared_ptr<MaturityInterfaceBase>>
75		MaturityInterfaceBase::live_objects;
76
77		/**
78		* @brief Rcpp interface for logistic maturity to instantiate the object from R:
79		* logistic_maturity <- methods::new(logistic_maturity).
80		*/
81		class LogisticMaturityInterface : public MaturityInterfaceBase {
82		public:
83		/**
84		* @brief The index value at which the response reaches 0.5.
85		*/
86		ParameterVector inflection_point;
87		/**
88		* @brief The width of the curve at the inflection point.
89		*/
90		ParameterVector slope;
91
92		/**
93		* @brief The constructor.
94		*/
95	36x	LogisticMaturityInterface() : MaturityInterfaceBase() {
96	36x	MaturityInterfaceBase::live_objects[this->id] =
97	72x	std::make_shared<LogisticMaturityInterface>(*this);
98	36x	FIMSRcppInterfaceBase::fims_interface_objects.push_back(
99	36x	MaturityInterfaceBase::live_objects[this->id]);
100		}
101
102		/**
103		* @brief Construct a new Logistic Maturity Interface object
104		*
105		* @param other
106		*/
107	36x	LogisticMaturityInterface(const LogisticMaturityInterface& other)
108	36x	: MaturityInterfaceBase(other),
109	36x	inflection_point(other.inflection_point),
110	36x	slope(other.slope) {}
111
112		/**
113		* @brief The destructor.
114		*/
115	216x	virtual ~LogisticMaturityInterface() {}
116
117		/**
118		* @brief Gets the ID of the interface base object.
119		* @return The ID.
120		*/
121	35x	virtual uint32_t get_id() { return this->id; }
122
123		/**
124		* @brief Evaluate maturity using the logistic function.
125		* @param x The independent variable in the logistic function (e.g., age or
126		* size in maturity).
127		*/
128	1x	virtual double evaluate(double x) {
129	1x	fims_popdy::LogisticMaturity<double> LogisticMat;
130	1x	LogisticMat.inflection_point.resize(1);
131	1x	LogisticMat.inflection_point[0] = this->inflection_point[0].initial_value_m;
132	1x	LogisticMat.slope.resize(1);
133	1x	LogisticMat.slope[0] = this->slope[0].initial_value_m;
134	2x	return LogisticMat.evaluate(x);
135		}
136
137		/**
138		* @brief Extracts derived quantities back to the Rcpp interface object from
139		* the Information object.
140		*/
141	24x	virtual void finalize() {
142	24x	if (this->finalized) {
143		// log warning that finalize has been called more than once.
144	1x	FIMS_WARNING_LOG("Logistic Maturity " + fims::to_string(this->id) +
145		" has been finalized already.");
146		}
147
148	24x	this->finalized = true; // indicate this has been called already
149
150		std::shared_ptr<fims_info::Information<double>> info =
151	24x	fims_info::Information<double>::GetInstance();
152
153	24x	fims_info::Information<double>::maturity_models_iterator it;
154
155		// search for maturity in Information
156	24x	it = info->maturity_models.find(this->id);
157		// if not found, just return
158	24x	if (it == info->maturity_models.end()) {
159	!	FIMS_WARNING_LOG("Logistic Maturity " + fims::to_string(this->id) +
160		" not found in Information.");
161	!	return;
162		} else {
163		std::shared_ptr<fims_popdy::LogisticMaturity<double>> mat =
164		std::dynamic_pointer_cast<fims_popdy::LogisticMaturity<double>>(
165	24x	it->second);
166
167	48x	for (size_t i = 0; i < inflection_point.size(); i++) {
168	24x	if (this->inflection_point[i].estimation_type_m.get() == "constant") {
169	24x	this->inflection_point[i].final_value_m =
170	24x	this->inflection_point[i].initial_value_m;
171		} else {
172	!	this->inflection_point[i].final_value_m = mat->inflection_point[i];
173		}
174		}
175
176	48x	for (size_t i = 0; i < slope.size(); i++) {
177	24x	if (this->slope[i].estimation_type_m.get() == "constant") {
178	24x	this->slope[i].final_value_m = this->slope[i].initial_value_m;
179		} else {
180	!	this->slope[i].final_value_m = mat->slope[i];
181		}
182		}
183		}
184		}
185
186		/**
187		* @brief Converts the data to json representation for the output.
188		* @return A string is returned specifying that the module relates to the
189		* maturity interface with logistic maturity. It also returns the ID and the
190		* parameters. This string is formatted for a json file.
191		*/
192	24x	virtual std::string to_json() {
193	24x	std::stringstream ss;
194	24x	ss << "{\n";
195	24x	ss << " \"module_name\": \"Maturity\",\n";
196	24x	ss << " \"module_type\": \"Logistic\",\n";
197	24x	ss << " \"module_id\": " << this->id << ",\n";
198
199	24x	ss << " \"parameters\": [\n{\n";
200	24x	ss << " \"name\": \"inflection_point\",\n";
201	24x	ss << " \"id\":" << this->inflection_point.id_m << ",\n";
202	24x	ss << " \"type\": \"vector\",\n";
203	24x	ss << " \"dimensionality\": {\n";
204	24x	ss << " \"header\": [null],\n";
205	24x	ss << " \"dimensions\": [1]\n},\n";
206	24x	ss << " \"values\":" << this->inflection_point << "},\n ";
207
208	24x	ss << "{\n";
209	24x	ss << " \"name\": \"slope\",\n";
210	24x	ss << " \"id\":" << this->slope.id_m << ",\n";
211	24x	ss << " \"type\": \"vector\",\n";
212	24x	ss << " \"dimensionality\": {\n";
213	24x	ss << " \"header\": [null],\n";
214	24x	ss << " \"dimensions\": [1]\n},\n";
215	24x	ss << " \"values\":" << this->slope << "}]\n";
216
217	24x	ss << "}";
218
219	48x	return ss.str();
220		}
221
222		#ifdef TMB_MODEL
223
224		template <typename Type>
225	120x	bool add_to_fims_tmb_internal() {
226	120x	std::shared_ptr<fims_info::Information<Type>> info =
227		fims_info::Information<Type>::GetInstance();
228
229	120x	std::shared_ptr<fims_popdy::LogisticMaturity<Type>> maturity =
230		std::make_shared<fims_popdy::LogisticMaturity<Type>>();
231
232		// set relative info
233	120x	maturity->id = this->id;
234	120x	std::stringstream ss;
235	120x	maturity->inflection_point.resize(this->inflection_point.size());
236	240x	for (size_t i = 0; i < this->inflection_point.size(); i++) {
237	120x	maturity->inflection_point[i] = this->inflection_point[i].initial_value_m;
238	120x	if (this->inflection_point[i].estimation_type_m.get() ==
239		"fixed_effects") {
240	!	ss.str("");
241	!	ss << "Maturity." << this->id << ".inflection_point."
242	!	<< this->inflection_point[i].id_m;
243	!	info->RegisterParameterName(ss.str());
244	!	info->RegisterParameter(maturity->inflection_point[i]);
245		}
246	120x	if (this->inflection_point[i].estimation_type_m.get() ==
247		"random_effects") {
248	!	ss.str("");
249	!	ss << "Maturity." << this->id << ".inflection_point."
250	!	<< this->inflection_point[i].id_m;
251	!	info->RegisterRandomEffectName(ss.str());
252	!	info->RegisterRandomEffect(maturity->inflection_point[i]);
253		}
254		}
255
256	120x	maturity->slope.resize(this->slope.size());
257	240x	for (size_t i = 0; i < this->slope.size(); i++) {
258	120x	maturity->slope[i] = this->slope[i].initial_value_m;
259	120x	if (this->slope[i].estimation_type_m.get() == "fixed_effects") {
260	!	ss.str("");
261	!	ss << "Maturity." << this->id << ".slope." << this->slope[i].id_m;
262	!	info->RegisterParameterName(ss.str());
263	!	info->RegisterParameter(maturity->slope[i]);
264		}
265	120x	if (this->slope[i].estimation_type_m.get() == "random_effects") {
266	!	ss.str("");
267	!	ss << "Maturity." << this->id << ".slope." << this->slope[i].id_m;
268	!	info->RegisterRandomEffect(maturity->slope[i]);
269	!	info->RegisterRandomEffectName(ss.str());
270		}
271		}
272
273		// add to Information
274	120x	info->maturity_models[maturity->id] = maturity;
275
276	120x	return true;
277		}
278
279		/**
280		* @brief Adds the parameters to the TMB model.
281		* @return A boolean of true.
282		*/
283	30x	virtual bool add_to_fims_tmb() {
284	30x	this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
285	30x	this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
286
287	30x	return true;
288		}
289
290		#endif
291		};
292
293		#endif

1		/**
2		* @file rcpp_population.hpp
3		* @brief The Rcpp interface to declare different types of populations. Allows
4		* for the use of methods::new() in R.
5		* @copyright This file is part of the NOAA, National Marine Fisheries Service
6		* Fisheries Integrated Modeling System project. See LICENSE in the source
7		* folder for reuse information.
8		*/
9		#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_POPULATION_HPP
10		#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_POPULATION_HPP
11
12		#include "../../../population_dynamics/population/population.hpp"
13		#include "rcpp_interface_base.hpp"
14
15		/**
16		* @brief Rcpp interface that serves as the parent class for Rcpp population
17		* interfaces. This type should be inherited and not called from R directly.
18		*/
19		class PopulationInterfaceBase : public FIMSRcppInterfaceBase {
20		public:
21		/**
22		* @brief The static id of the PopulationInterfaceBase object.
23		*/
24		static uint32_t id_g;
25		/**
26		* @brief The local id of the PopulationInterfaceBase object.
27		*/
28		uint32_t id;
29		/**
30		* @brief The map associating the IDs of PopulationInterfaceBase to the
31		* objects. This is a live object, which is an object that has been created
32		* and lives in memory.
33		*/
34		static std::map<uint32_t, std::shared_ptr<PopulationInterfaceBase>>
35		live_objects;
36
37		/**
38		* @brief Initialize the catch at age model.
39		*
40		*/
41		SharedBoolean initialize_catch_at_age;
42		/**
43		* @brief Initialize the surplus production model.
44		*
45		*/
46		SharedBoolean initialize_surplus_production;
47		/**
48		* @brief The constructor.
49		*/
50	34x	PopulationInterfaceBase() {
51	34x	this->id = PopulationInterfaceBase::id_g++;
52		/* Create instance of map: key is id and value is pointer to
53		PopulationInterfaceBase */
54		// PopulationInterfaceBase::live_objects[this->id] = this;
55		}
56
57		/**
58		* @brief Construct a new Population Interface Base object
59		*
60		* @param other
61		*/
62	34x	PopulationInterfaceBase(const PopulationInterfaceBase &other)
63	34x	: id(other.id) {}
64
65		/**
66		* @brief The destructor.
67		*/
68	67x	virtual ~PopulationInterfaceBase() {}
69
70		/**
71		* @brief Get the ID for the child population interface objects to inherit.
72		*/
73		virtual uint32_t get_id() = 0;
74		};
75		// static id of the PopulationInterfaceBase object
76		uint32_t PopulationInterfaceBase::id_g = 1;
77		// local id of the PopulationInterfaceBase object map relating the ID of the
78		// PopulationInterfaceBase to the PopulationInterfaceBase objects
79		std::map<uint32_t, std::shared_ptr<PopulationInterfaceBase>>
80		PopulationInterfaceBase::live_objects;
81
82		/**
83		* @brief Rcpp interface for a new Population to instantiate from R:
84		* population <- methods::new(population)
85		*/
86		class PopulationInterface : public PopulationInterfaceBase {
87		public:
88		/**
89		* @brief The number of age bins.
90		*/
91		SharedInt n_ages = 0;
92		/**
93		* @brief The number of fleets.
94		*/
95		SharedInt n_fleets;
96		/**
97		* list of fleets that operate on this population.
98		*/
99		std::shared_ptr<std::set<uint32_t>> fleet_ids;
100		/**
101		* Iterator for fleet ids.
102		*/
103		typedef typename std::set<uint32_t>::iterator fleet_ids_iterator;
104		/**
105		* @brief The number of years.
106		*/
107		SharedInt n_years;
108		/**
109		* @brief The number of length bins.
110		*/
111		SharedInt n_lengths;
112		/**
113		* @brief The ID of the maturity module.
114		*/
115		SharedInt maturity_id;
116		/**
117		* @brief The ID of the growth module.
118		*/
119		SharedInt growth_id;
120		/**
121		* @brief The ID of the recruitment module.
122		*/
123		SharedInt recruitment_id;
124		/**
125		* @brief The ID of the recruitment process module.
126		*/
127		SharedInt recruitment_err_id;
128		/**
129		* @brief The natural log of the natural mortality for each year.
130		*/
131		ParameterVector log_M;
132		/**
133		* @brief The population spawning biomass ratio for each year.
134		*/
135		ParameterVector spawning_biomass_ratio;
136		/**
137		* @brief Log of the population annual fishing mortality multiplier.
138		*/
139		ParameterVector log_f_multiplier;
140		/**
141		* @brief The natural log of the initial numbers at age.
142		*/
143		ParameterVector log_init_naa;
144		/**
145		* @brief Ages that are modeled in the population, the length of this vector
146		* should equal \"n_ages\".
147		*/
148		RealVector ages;
149		/**
150		* @brief The name for the population.
151		*/
152		SharedString name = fims::to_string("NA");
153
154		/**
155		* @brief The constructor.
156		*/
157	34x	PopulationInterface() : PopulationInterfaceBase() {
158	34x	this->fleet_ids = std::make_shared<std::set<uint32_t>>();
159		std::shared_ptr<PopulationInterface> population =
160	34x	std::make_shared<PopulationInterface>(*this);
161	34x	FIMSRcppInterfaceBase::fims_interface_objects.push_back(population);
162	34x	PopulationInterfaceBase::live_objects[this->id] = population;
163		}
164
165		/**
166		* @brief Construct a new Population Interface object
167		*
168		* @param other
169		*/
170	34x	PopulationInterface(const PopulationInterface &other)
171	34x	: PopulationInterfaceBase(other),
172	34x	n_ages(other.n_ages),
173	34x	n_fleets(other.n_fleets),
174	34x	fleet_ids(other.fleet_ids),
175	34x	n_years(other.n_years),
176	34x	n_lengths(other.n_lengths),
177	34x	maturity_id(other.maturity_id),
178	34x	growth_id(other.growth_id),
179	34x	recruitment_id(other.recruitment_id),
180	34x	recruitment_err_id(other.recruitment_id),
181	34x	log_M(other.log_M),
182	34x	spawning_biomass_ratio(other.spawning_biomass_ratio),
183	34x	log_f_multiplier(other.log_f_multiplier),
184	34x	log_init_naa(other.log_init_naa),
185	34x	ages(other.ages),
186	68x	name(other.name) {}
187
188		/**
189		* @brief The destructor.
190		*/
191	200x	virtual ~PopulationInterface() {}
192
193		/**
194		* @brief Gets the ID of the interface base object.
195		* @return The ID.
196		*/
197	128x	virtual uint32_t get_id() { return this->id; }
198
199		/**
200		* @brief Sets the name of the population.
201		* @param name The name to set.
202		*/
203	!	void SetName(const std::string &name) { this->name.set(name); }
204
205		/**
206		* @brief Gets the name of the population.
207		* @return The name.
208		*/
209	!	std::string GetName() const { return this->name.get(); }
210
211		/**
212		* @brief Sets the unique ID for the Maturity object.
213		* @param maturity_id Unique ID for the Maturity object.
214		*/
215	33x	void SetMaturityID(uint32_t maturity_id) {
216	33x	this->maturity_id.set(maturity_id);
217		}
218
219		/**
220		* @brief Set the unique ID for the growth object.
221		* @param growth_id Unique ID for the growth object.
222		*/
223	33x	void SetGrowthID(uint32_t growth_id) { this->growth_id.set(growth_id); }
224
225		/**
226		* @brief Set the unique ID for the recruitment object.
227		* @param recruitment_id Unique ID for the recruitment object.
228		*/
229	33x	void SetRecruitmentID(uint32_t recruitment_id) {
230	33x	this->recruitment_id.set(recruitment_id);
231		}
232
233		/**
234		* @brief Add a fleet id to the list of fleets
235		* operating on this population.
236		*/
237	62x	void AddFleet(uint32_t fleet_id) { this->fleet_ids->insert(fleet_id); }
238
239		/**
240		* @brief Extracts derived quantities back to the Rcpp interface object from
241		* the Information object.
242		*/
243	!	virtual void finalize() {
244	!	if (this->finalized) {
245		// log warning that finalize has been called more than once.
246	!	FIMS_WARNING_LOG("Population " + fims::to_string(this->id) +
247		" has been finalized already.");
248		}
249
250	!	this->finalized = true; // indicate this has been called already
251
252		std::shared_ptr<fims_info::Information<double>> info =
253	!	fims_info::Information<double>::GetInstance();
254
255	!	fims_info::Information<double>::population_iterator it;
256
257	!	it = info->populations.find(this->id);
258
259		std::shared_ptr<fims_popdy::Population<double>> pop =
260	!	info->populations[this->id];
261	!	it = info->populations.find(this->id);
262	!	if (it == info->populations.end()) {
263	!	FIMS_WARNING_LOG("Population " + fims::to_string(this->id) +
264		" not found in Information.");
265	!	return;
266		} else {
267	!	for (size_t i = 0; i < this->log_M.size(); i++) {
268	!	if (this->log_M[i].estimation_type_m.get() == "constant") {
269	!	this->log_M[i].final_value_m = this->log_M[i].initial_value_m;
270		} else {
271	!	this->log_M[i].final_value_m = pop->log_M[i];
272		}
273		}
274
275	!	for (size_t i = 0; i < this->log_f_multiplier.size(); i++) {
276	!	if (this->log_f_multiplier[i].estimation_type_m.get() == "constant") {
277	!	this->log_f_multiplier[i].final_value_m =
278	!	this->log_f_multiplier[i].initial_value_m;
279		} else {
280	!	this->log_f_multiplier[i].final_value_m = pop->log_f_multiplier[i];
281		}
282		}
283
284	!	for (size_t i = 0; i < this->log_init_naa.size(); i++) {
285	!	if (this->log_init_naa[i].estimation_type_m.get() == "constant") {
286	!	this->log_init_naa[i].final_value_m =
287	!	this->log_init_naa[i].initial_value_m;
288		} else {
289	!	this->log_init_naa[i].final_value_m = pop->log_init_naa[i];
290		}
291		}
292		}
293		}
294
295		#ifdef TMB_MODEL
296
297		template <typename Type>
298	120x	bool add_to_fims_tmb_internal() {
299	120x	std::shared_ptr<fims_info::Information<Type>> info =
300		fims_info::Information<Type>::GetInstance();
301
302	120x	std::shared_ptr<fims_popdy::Population<Type>> population =
303		std::make_shared<fims_popdy::Population<Type>>();
304
305	120x	std::stringstream ss;
306
307		// set relative info
308	120x	population->id = this->id;
309	120x	population->n_years = this->n_years.get();
310	120x	population->n_fleets = this->n_fleets.get();
311		// only define ages if n_ages greater than 0
312	120x	if (this->n_ages.get() > 0) {
313	120x	population->n_ages = this->n_ages.get();
314	120x	if (static_cast<size_t>(this->n_ages.get()) == this->ages.size()) {
315	120x	population->ages.resize(this->n_ages.get());
316		} else {
317	!	warning("The ages vector is not of size n_ages.");
318		}
319		}
320
321	120x	fleet_ids_iterator it;
322	352x	for (it = this->fleet_ids->begin(); it != this->fleet_ids->end(); it++) {
323	232x	population->fleet_ids.insert(*it);
324		}
325
326	120x	population->growth_id = this->growth_id.get();
327	120x	population->recruitment_id = this->recruitment_id.get();
328	120x	population->maturity_id = this->maturity_id.get();
329	120x	population->log_M.resize(this->log_M.size());
330
331	120x	if (this->log_f_multiplier.size() ==
332	120x	static_cast<size_t>(this->n_years.get())) {
333	62x	population->log_f_multiplier.resize(this->log_f_multiplier.size());
334		} else {
335	58x	FIMS_WARNING_LOG(
336		"The log_f_multiplier vector is not of size n_years. Filling with "
337		"zeros.");
338	29x	this->log_f_multiplier.resize((this->n_years.get()));
339	914x	for (size_t i = 0; i < log_f_multiplier.size(); i++) {
340	885x	this->log_f_multiplier[i].initial_value_m = static_cast<double>(0.0);
341	2655x	this->log_f_multiplier[i].estimation_type_m.set("constant");
342		}
343	29x	population->log_f_multiplier.resize(this->log_f_multiplier.size());
344		}
345
346	120x	if (this->spawning_biomass_ratio.size() ==
347	120x	static_cast<size_t>(this->n_years.get() + 1)) {
348	30x	population->spawning_biomass_ratio.resize(
349		this->spawning_biomass_ratio.size());
350		} else {
351	60x	FIMS_WARNING_LOG(
352		"Setting spawning_biomass_ratio vector to size n_years + 1.");
353	30x	this->spawning_biomass_ratio.resize((this->n_years.get() + 1));
354	30x	population->spawning_biomass_ratio.resize(
355		this->spawning_biomass_ratio.size());
356		}
357	120x	info->variable_map[this->spawning_biomass_ratio.id_m] =
358	120x	&(population)->spawning_biomass_ratio;
359
360	120x	population->log_init_naa.resize(this->log_init_naa.size());
361	44520x	for (size_t i = 0; i < log_M.size(); i++) {
362	44400x	population->log_M[i] = this->log_M[i].initial_value_m;
363	44400x	if (this->log_M[i].estimation_type_m.get() == "fixed_effects") {
364	!	ss.str("");
365	!	ss << "Population." << this->id << ".log_M." << this->log_M[i].id_m;
366	!	info->RegisterParameterName(ss.str());
367	!	info->RegisterParameter(population->log_M[i]);
368		}
369	44400x	if (this->log_M[i].estimation_type_m.get() == "random_effects") {
370	!	ss.str("");
371	!	ss << "Population." << this->id << ".log_M." << this->log_M[i].id_m;
372	!	info->RegisterRandomEffectName(ss.str());
373	!	info->RegisterRandomEffect(population->log_M[i]);
374		}
375		}
376	120x	info->variable_map[this->log_M.id_m] = &(population)->log_M;
377
378	3820x	for (size_t i = 0; i < log_f_multiplier.size(); i++) {
379	3700x	population->log_f_multiplier[i] =
380	3700x	this->log_f_multiplier[i].initial_value_m;
381	3700x	if (this->log_f_multiplier[i].estimation_type_m.get() ==
382		"fixed_effects") {
383	!	ss.str("");
384	!	ss << "Population." << this->id << ".log_f_multiplier."
385	!	<< this->log_f_multiplier[i].id_m;
386	!	info->RegisterParameterName(ss.str());
387	!	info->RegisterParameter(population->log_f_multiplier[i]);
388		}
389	3700x	if (this->log_f_multiplier[i].estimation_type_m.get() ==
390		"random_effects") {
391	40x	ss.str("");
392	40x	ss << "Population." << this->id << ".log_f_multiplier."
393	40x	<< this->log_f_multiplier[i].id_m;
394	40x	info->RegisterRandomEffectName(ss.str());
395	40x	info->RegisterRandomEffect(population->log_f_multiplier[i]);
396		}
397		}
398	120x	info->variable_map[this->log_f_multiplier.id_m] =
399	120x	&(population)->log_f_multiplier;
400
401	1560x	for (size_t i = 0; i < log_init_naa.size(); i++) {
402	1440x	population->log_init_naa[i] = this->log_init_naa[i].initial_value_m;
403	1440x	if (this->log_init_naa[i].estimation_type_m.get() == "fixed_effects") {
404	1392x	ss.str("");
405	1392x	ss << "Population." << this->id << ".log_init_naa."
406	1392x	<< this->log_init_naa[i].id_m;
407	1392x	info->RegisterParameterName(ss.str());
408	1392x	info->RegisterParameter(population->log_init_naa[i]);
409		}
410	1440x	if (this->log_init_naa[i].estimation_type_m.get() == "random_effects") {
411	!	ss.str("");
412	!	ss << "Population." << this->id << ".log_init_naa."
413	!	<< this->log_init_naa[i].id_m;
414	!	info->RegisterRandomEffectName(ss.str());
415	!	info->RegisterRandomEffect(population->log_init_naa[i]);
416		}
417		}
418	120x	info->variable_map[this->log_init_naa.id_m] = &(population)->log_init_naa;
419
420	1560x	for (size_t i = 0; i < ages.size(); i++) {
421	1440x	population->ages[i] = this->ages[i];
422		}
423
424		// add to Information
425	120x	info->populations[population->id] = population;
426
427	120x	return true;
428		}
429
430		/**
431		* @brief Adds the parameters to the TMB model.
432		* @return A boolean of true.
433		*/
434	30x	virtual bool add_to_fims_tmb() {
435	30x	this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
436	30x	this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
437
438	30x	return true;
439		}
440
441		#endif
442		};
443
444		#endif

1		/**
2		* @file rcpp_recruitment.hpp
3		* @brief The Rcpp interface to declare different types of recruitment, e.g.,
4		* Beverton--Holt stock--recruitment relationship. Allows for the use of
5		* methods::new() in R.
6		* @copyright This file is part of the NOAA, National Marine Fisheries Service
7		* Fisheries Integrated Modeling System project. See LICENSE in the source
8		* folder for reuse information.
9		*/
10		#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_RECRUITMENT_HPP
11		#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_RECRUITMENT_HPP
12
13		#include "../../../population_dynamics/recruitment/recruitment.hpp"
14		#include "rcpp_interface_base.hpp"
15
16		/**
17		* @brief Rcpp interface that serves as the parent class for Rcpp recruitment
18		* interfaces. This type should be inherited and not called from R directly.
19		*/
20		class RecruitmentInterfaceBase : public FIMSRcppInterfaceBase {
21		public:
22		/**
23		* @brief The static id of the RecruitmentInterfaceBase object.
24		*/
25		static uint32_t id_g;
26		/**
27		* @brief The local id of the RecruitmentInterfaceBase object.
28		*/
29		uint32_t id;
30		/**
31		* @brief The process id of the RecruitmentInterfaceBase object.
32		*/
33		SharedInt process_id = -999;
34		/**
35		* @brief The map associating the IDs of RecruitmentInterfaceBase to the
36		* objects. This is a live object, which is an object that has been created
37		* and lives in memory.
38		*/
39		static std::map<uint32_t, std::shared_ptr<RecruitmentInterfaceBase>>
40		live_objects;
41
42		/**
43		* @brief The constructor.
44		*/
45	73x	RecruitmentInterfaceBase() {
46	73x	this->id = RecruitmentInterfaceBase::id_g++;
47		/* Create instance of map: key is id and value is pointer to
48		RecruitmentInterfaceBase */
49		// RecruitmentInterfaceBase::live_objects[this->id] = this;
50		}
51
52		/**
53		* @brief Construct a new Recruitment Interface Base object
54		*
55		* @param other
56		*/
57	73x	RecruitmentInterfaceBase(const RecruitmentInterfaceBase &other)
58	73x	: id(other.id), process_id(other.process_id) {}
59
60		/**
61		* @brief The destructor.
62		*/
63	146x	virtual ~RecruitmentInterfaceBase() {}
64
65		/**
66		* @brief Get the ID for the child recruitment interface objects to inherit.
67		*/
68		virtual uint32_t get_id() = 0;
69
70		/**
71		* @brief A method for each child recruitment interface object to inherit so
72		* each recruitment option can have an evaluate_mean() function.
73		*/
74		virtual double evaluate_mean(double spawners, double ssbzero) = 0;
75
76		/**
77		* @brief A method for each child recruitment process interface object to
78		* inherit so each recruitment process option can have a evaluate_process()
79		* function.
80		*/
81		virtual double evaluate_process(size_t pos) = 0;
82		};
83		// static id of the RecruitmentInterfaceBase object
84		uint32_t RecruitmentInterfaceBase::id_g = 1;
85		// local id of the RecruitmentInterfaceBase object map relating the ID of the
86		// RecruitmentInterfaceBase to the RecruitmentInterfaceBase objects
87		std::map<uint32_t, std::shared_ptr<RecruitmentInterfaceBase>>
88		RecruitmentInterfaceBase::live_objects;
89
90		/**
91		* @brief Rcpp interface for Beverton--Holt to instantiate from R:
92		* beverton_holt <- methods::new(beverton_holt).
93		*/
94		class BevertonHoltRecruitmentInterface : public RecruitmentInterfaceBase {
95		public:
96		/**
97		* @brief The number of years.
98		*/
99		SharedInt n_years;
100		/**
101		* @brief The logistic transformation of steepness (h; productivity of the
102		* population), where the parameter is transformed to constrain it between
103		* 0.2 and 1.0.
104		*/
105		ParameterVector logit_steep;
106		/**
107		* @brief The natural log of recruitment at unfished biomass.
108		*/
109		ParameterVector log_rzero;
110		/**
111		* @brief The natural log of recruitment deviations.
112		*/
113		ParameterVector log_devs;
114		/**
115		* @brief The recruitment random effect parameter on the natural log scale.
116		*/
117		ParameterVector log_r;
118		/**
119		* @brief Expectation of the recruitment process.
120		*/
121		ParameterVector log_expected_recruitment;
122		/**
123		* @brief The estimate of the logit transformation of steepness.
124		*/
125		fims_double estimated_logit_steep;
126		/**
127		* @brief The estimate of the natural log of recruitment at unfished biomass.
128		*/
129		fims_double estimated_log_rzero;
130		/**
131		* @brief The estimates of the natural log of recruitment deviations.
132		*/
133		RealVector estimated_log_devs;
134
135		/**
136		* @brief The constructor.
137		*/
138	40x	BevertonHoltRecruitmentInterface() : RecruitmentInterfaceBase() {
139	40x	RecruitmentInterfaceBase::live_objects[this->id] =
140	80x	std::make_shared<BevertonHoltRecruitmentInterface>(*this);
141	40x	FIMSRcppInterfaceBase::fims_interface_objects.push_back(
142	40x	RecruitmentInterfaceBase::live_objects[this->id]);
143		}
144
145		/**
146		* @brief Construct a new Beverton--Holt Recruitment Interface object.
147		*
148		* @param other The passed object to copy.
149		*/
150	40x	BevertonHoltRecruitmentInterface(
151		const BevertonHoltRecruitmentInterface &other)
152	40x	: RecruitmentInterfaceBase(other),
153	40x	n_years(other.n_years),
154	40x	logit_steep(other.logit_steep),
155	40x	log_rzero(other.log_rzero),
156	40x	log_devs(other.log_devs),
157	40x	log_r(other.log_r),
158	40x	log_expected_recruitment(other.log_expected_recruitment),
159	40x	estimated_logit_steep(other.estimated_logit_steep),
160	40x	estimated_log_rzero(other.estimated_log_rzero),
161	80x	estimated_log_devs(other.estimated_log_devs) {}
162
163		/**
164		* @brief The destructor.
165		*/
166	240x	virtual ~BevertonHoltRecruitmentInterface() {}
167
168		/**
169		* @brief Gets the ID of the interface base object.
170		* @return The ID.
171		*/
172	35x	virtual uint32_t get_id() { return this->id; }
173
174		/**
175		* @brief Set the unique ID for the recruitment process object.
176		* @param process_id Unique ID for the recruitment process object.
177		*/
178	32x	void SetRecruitmentProcessID(uint32_t process_id) {
179	32x	this->process_id.set(process_id);
180		}
181
182		/**
183		* @brief Evaluate recruitment using the Beverton--Holt stock--recruitment
184		* relationship.
185		* @param spawners Spawning biomass per time step.
186		* @param ssbzero The biomass at unfished levels.
187		* TODO: Change to sbzero if continuing to use acronyms.
188		*/
189	2x	virtual double evaluate_mean(double spawners, double ssbzero) {
190	2x	fims_popdy::SRBevertonHolt<double> BevHolt;
191	2x	BevHolt.logit_steep.resize(1);
192	2x	BevHolt.logit_steep[0] = this->logit_steep[0].initial_value_m;
193	2x	if (this->logit_steep[0].initial_value_m == 1.0) {
194	1x	warning(
195		"Steepness is subject to a logit transformation. "
196		"Fixing it at 1.0 is not currently possible.");
197		}
198	2x	BevHolt.log_rzero.resize(1);
199	2x	BevHolt.log_rzero[0] = this->log_rzero[0].initial_value_m;
200
201	4x	return BevHolt.evaluate_mean(spawners, ssbzero);
202		}
203
204		/**
205		* @brief Evaluate recruitment process - returns 0 in this module.
206		* @param pos Position index, e.g., which year.
207		*/
208	!	virtual double evaluate_process(size_t pos) { return 0; }
209
210		/**
211		* @brief Extracts derived quantities back to the Rcpp interface object from
212		* the Information object.
213		*/
214	24x	virtual void finalize() {
215	24x	if (this->finalized) {
216		// log warning that finalize has been called more than once.
217	1x	FIMS_WARNING_LOG("Beverton-Holt Recruitment " +
218		fims::to_string(this->id) +
219		" has been finalized already.");
220		}
221
222	24x	this->finalized = true; // indicate this has been called already
223
224		std::shared_ptr<fims_info::Information<double>> info =
225	24x	fims_info::Information<double>::GetInstance();
226
227	24x	fims_info::Information<double>::recruitment_models_iterator it;
228
229	24x	it = info->recruitment_models.find(this->id);
230
231	24x	if (it == info->recruitment_models.end()) {
232	!	FIMS_WARNING_LOG("Beverton-Holt Recruitment " +
233		fims::to_string(this->id) +
234		" not found in Information.");
235	!	return;
236		} else {
237		std::shared_ptr<fims_popdy::SRBevertonHolt<double>> recr =
238		std::dynamic_pointer_cast<fims_popdy::SRBevertonHolt<double>>(
239	24x	it->second);
240
241	48x	for (size_t i = 0; i < this->logit_steep.size(); i++) {
242	24x	if (this->logit_steep[i].estimation_type_m.get() == "constant") {
243	24x	this->logit_steep[i].final_value_m =
244	24x	this->logit_steep[i].initial_value_m;
245		} else {
246	!	this->logit_steep[i].final_value_m = recr->logit_steep[i];
247		}
248		}
249
250	48x	for (size_t i = 0; i < log_rzero.size(); i++) {
251	24x	if (log_rzero[i].estimation_type_m.get() == "constant") {
252	2x	this->log_rzero[i].final_value_m = this->log_rzero[i].initial_value_m;
253		} else {
254	22x	this->log_rzero[i].final_value_m = recr->log_rzero[i];
255		}
256		}
257
258	717x	for (size_t i = 0; i < this->log_devs.size(); i++) {
259	693x	if (this->log_devs[i].estimation_type_m.get() == "constant") {
260	403x	this->log_devs[i].final_value_m = this->log_devs[i].initial_value_m;
261		} else {
262	290x	this->log_devs[i].final_value_m = recr->log_recruit_devs[i];
263		}
264		}
265
266	440x	for (size_t i = 0; i < this->log_r.size(); i++) {
267	416x	if (this->log_r[i].estimation_type_m.get() == "constant") {
268	387x	this->log_r[i].final_value_m = this->log_r[i].initial_value_m;
269		} else {
270	29x	this->log_r[i].final_value_m = recr->log_r[i];
271		}
272		}
273		}
274		}
275
276		/**
277		* @brief Converts the data to json representation for the output.
278		* @return A string is returned specifying that the module relates to the
279		* recruitment interface with Beverton--Holt stock--recruitment relationship.
280		* It also returns the ID and the parameters. This string is formatted for a
281		* json file.
282		*/
283	24x	virtual std::string to_json() {
284	24x	std::stringstream ss;
285
286	24x	ss << "{\n";
287	24x	ss << " \"module_name\": \"Recruitment\",\n";
288	24x	ss << " \"module_type\": \"Beverton-Holt\",\n";
289	24x	ss << " \"module_id\": " << this->id << ",\n";
290
291	24x	ss << " \"parameters\": [\n{\n";
292	24x	ss << " \"name\": \"logit_steep\",\n";
293	24x	ss << " \"id\":" << this->logit_steep.id_m << ",\n";
294	24x	ss << " \"type\": \"vector\",\n";
295	24x	ss << " \"dimensionality\": {\n";
296	24x	ss << " \"header\": [null],\n";
297	24x	ss << " \"dimensions\": [" << this->logit_steep.size() << "]\n},\n";
298	24x	ss << " \"values\":" << this->logit_steep << "},\n";
299
300	24x	ss << "{\n";
301	24x	ss << " \"name\": \"log_rzero\",\n";
302	24x	ss << " \"id\":" << this->log_rzero.id_m << ",\n";
303	24x	ss << " \"type\": \"vector\",\n";
304	24x	ss << " \"dimensionality\": {\n";
305	24x	ss << " \"header\": [null],\n";
306	24x	ss << " \"dimensions\": [" << this->log_rzero.size() << "]\n},\n";
307	24x	ss << " \"values\":" << this->log_rzero << "},\n";
308
309	24x	ss << "{\n";
310	24x	ss << " \"name\": \"log_devs\",\n";
311	24x	ss << " \"id\":" << this->log_devs.id_m << ",\n";
312	24x	ss << " \"type\": \"vector\",\n";
313	24x	ss << " \"dimensionality\": {\n";
314	24x	ss << " \"header\": [\"n_years-1\"],\n";
315	24x	ss << " \"dimensions\": [" << this->log_devs.size() << "]\n},\n";
316	24x	ss << " \"values\":" << this->log_devs << "}]\n";
317	24x	ss << "}";
318	48x	return ss.str();
319		}
320
321		#ifdef TMB_MODEL
322
323		template <typename Type>
324	128x	bool add_to_fims_tmb_internal() {
325	128x	std::shared_ptr<fims_info::Information<Type>> info =
326		fims_info::Information<Type>::GetInstance();
327
328	128x	std::shared_ptr<fims_popdy::SRBevertonHolt<Type>> recruitment =
329		std::make_shared<fims_popdy::SRBevertonHolt<Type>>();
330
331	128x	std::stringstream ss;
332
333		// set relative info
334	128x	recruitment->id = this->id;
335	128x	recruitment->process_id = this->process_id.get();
336		// set logit_steep
337	128x	recruitment->logit_steep.resize(this->logit_steep.size());
338	256x	for (size_t i = 0; i < this->logit_steep.size(); i++) {
339	128x	recruitment->logit_steep[i] = this->logit_steep[i].initial_value_m;
340
341	128x	if (this->logit_steep[i].estimation_type_m.get() == "fixed_effects") {
342	4x	ss.str("");
343	4x	ss << "Recruitment." << this->id << ".logit_steep."
344	4x	<< this->logit_steep[i].id_m;
345	4x	info->RegisterParameterName(ss.str());
346	4x	info->RegisterParameter(recruitment->logit_steep[i]);
347		}
348	128x	if (this->logit_steep[i].estimation_type_m.get() == "random_effects") {
349	4x	ss.str("");
350	4x	ss << "Recruitment." << this->id << ".logit_steep."
351	4x	<< this->logit_steep[i].id_m;
352	4x	info->RegisterRandomEffectName(ss.str());
353	4x	info->RegisterRandomEffect(recruitment->logit_steep[i]);
354		}
355		}
356	128x	info->variable_map[this->logit_steep.id_m] = &(recruitment)->logit_steep;
357
358		// set log_rzero
359	128x	recruitment->log_rzero.resize(this->log_rzero.size());
360	256x	for (size_t i = 0; i < this->log_rzero.size(); i++) {
361	128x	recruitment->log_rzero[i] = this->log_rzero[i].initial_value_m;
362
363	128x	if (this->log_rzero[i].estimation_type_m.get() == "fixed_effects") {
364	120x	ss.str("");
365	120x	ss << "Recruitment." << this->id << ".log_rzero."
366	120x	<< this->log_rzero[i].id_m;
367	120x	info->RegisterParameterName(ss.str());
368	120x	info->RegisterParameter(recruitment->log_rzero[i]);
369		}
370	128x	if (this->log_rzero[i].estimation_type_m.get() == "random_effects") {
371	4x	ss.str("");
372	4x	ss << "Recruitment." << this->id << ".log_rzero."
373	4x	<< this->log_rzero[i].id_m;
374	4x	info->RegisterRandomEffectName(ss.str());
375	4x	info->RegisterRandomEffect(recruitment->log_rzero[i]);
376		}
377		}
378	128x	info->variable_map[this->log_rzero.id_m] = &(recruitment)->log_rzero;
379		// set log_recruit_devs
380	128x	recruitment->log_recruit_devs.resize(this->log_devs.size());
381	3604x	for (size_t i = 0; i < this->log_devs.size(); i++) {
382	3476x	recruitment->log_recruit_devs[i] = this->log_devs[i].initial_value_m;
383
384	3476x	if (this->log_devs[i].estimation_type_m.get() == "fixed_effects") {
385	232x	ss.str("");
386	232x	ss << "Recruitment." << this->id << ".log_devs."
387	232x	<< this->log_devs[i].id_m;
388	232x	info->RegisterParameterName(ss.str());
389	232x	info->RegisterParameter(recruitment->log_recruit_devs[i]);
390		}
391	3476x	if (this->log_devs[i].estimation_type_m.get() == "random_effects") {
392	1584x	ss.str("");
393	1584x	ss << "Recruitment." << this->id << ".log_devs."
394	1584x	<< this->log_devs[i].id_m;
395	1584x	info->RegisterRandomEffectName(ss.str());
396	1584x	info->RegisterRandomEffect(recruitment->log_recruit_devs[i]);
397		}
398		}
399
400	128x	info->variable_map[this->log_devs.id_m] = &(recruitment)->log_recruit_devs;
401
402		// set log_r
403	128x	recruitment->log_r.resize(this->log_r.size());
404	2160x	for (size_t i = 0; i < log_r.size(); i++) {
405	2032x	recruitment->log_r[i] = this->log_r[i].initial_value_m;
406
407	2032x	if (this->log_r[i].estimation_type_m.get() == "fixed_effects") {
408	!	ss.str("");
409	!	ss << "Recruitment." << this->id << ".log_r." << this->log_r[i].id_m;
410	!	info->RegisterParameterName(ss.str());
411	!	info->RegisterParameter(recruitment->log_r[i]);
412		}
413	2032x	if (this->log_r[i].estimation_type_m.get() == "random_effects") {
414	116x	ss.str("");
415	116x	ss << "Recruitment." << this->id << ".log_r." << this->log_r[i].id_m;
416	116x	info->RegisterRandomEffectName(ss.str());
417	116x	info->RegisterRandomEffect(recruitment->log_r[i]);
418		}
419		}
420
421	128x	info->variable_map[this->log_r.id_m] = &(recruitment)->log_r;
422		// set log_expected_recruitment
423	128x	recruitment->log_expected_recruitment.resize(this->n_years.get() + 1);
424	3956x	for (size_t i = 0; i < static_cast<size_t>(this->n_years.get() + 1); i++) {
425	3828x	recruitment->log_expected_recruitment[i] = 0;
426		}
427	128x	info->variable_map[this->log_expected_recruitment.id_m] =
428	128x	&(recruitment)->log_expected_recruitment;
429
430		// add to Information
431	128x	info->recruitment_models[recruitment->id] = recruitment;
432
433	128x	return true;
434		}
435
436		/**
437		* @brief Adds the parameters to the TMB model.
438		* @return A boolean of true.
439		*/
440	32x	virtual bool add_to_fims_tmb() {
441	32x	this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
442	32x	this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
443
444	32x	return true;
445		}
446
447		#endif
448		};
449
450		/**
451		* @brief Rcpp interface for Log--Devs to instantiate from R:
452		* log_devs <- methods::new(log_devs).
453		*/
454		class LogDevsRecruitmentInterface : public RecruitmentInterfaceBase {
455		public:
456		/**
457		* @brief The constructor.
458		*/
459	32x	LogDevsRecruitmentInterface() : RecruitmentInterfaceBase() {
460	32x	FIMSRcppInterfaceBase::fims_interface_objects.push_back(
461	64x	std::make_shared<LogDevsRecruitmentInterface>(*this));
462		}
463
464		/**
465		* @brief The destructor.
466		*/
467	192x	virtual ~LogDevsRecruitmentInterface() {}
468
469		/**
470		* @brief Gets the ID of the interface base object.
471		* @return The ID.
472		*/
473	31x	virtual uint32_t get_id() { return this->id; }
474
475		/**
476		* @brief Evaluate mean - returns empty function for this module.
477		* @param spawners Spawning biomass per time step.
478		* @param ssbzero The biomass at unfished levels.
479		*/
480	!	virtual double evaluate_mean(double spawners, double ssbzero) { return 0; }
481
482		/**
483		* @brief Evaluate recruitment process using the Log--Devs approach.
484		* @param pos Position index, e.g., which year.
485		*/
486	!	virtual double evaluate_process(size_t pos) {
487	!	fims_popdy::LogDevs<double> LogDevs;
488
489	!	return LogDevs.evaluate_process(pos);
490		}
491
492		#ifdef TMB_MODEL
493
494		template <typename Type>
495	116x	bool add_to_fims_tmb_internal() {
496	116x	std::shared_ptr<fims_info::Information<Type>> info =
497		fims_info::Information<Type>::GetInstance();
498
499	116x	std::shared_ptr<fims_popdy::LogDevs<Type>> recruitment_process =
500		std::make_shared<fims_popdy::LogDevs<Type>>();
501
502	116x	recruitment_process->id = this->id;
503
504		// add to Information
505	116x	info->recruitment_process_models[recruitment_process->id] =
506		recruitment_process;
507
508	116x	return true;
509		}
510
511		/**
512		* @brief Adds the parameters to the TMB model.
513		* @return A boolean of true.
514		*/
515	29x	virtual bool add_to_fims_tmb() {
516	29x	this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
517	29x	this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
518
519	29x	return true;
520		}
521
522		#endif
523		};
524
525		/**
526		* @brief Rcpp interface for Log--R to instantiate from R:
527		* log_r <- methods::new(log_r).
528		*/
529		class LogRRecruitmentInterface : public RecruitmentInterfaceBase {
530		public:
531		/**
532		* @brief The constructor.
533		*/
534	1x	LogRRecruitmentInterface() : RecruitmentInterfaceBase() {
535	1x	FIMSRcppInterfaceBase::fims_interface_objects.push_back(
536	2x	std::make_shared<LogRRecruitmentInterface>(*this));
537		}
538
539		/**
540		* @brief The destructor.
541		*/
542	6x	virtual ~LogRRecruitmentInterface() {}
543
544		/**
545		* @brief Gets the ID of the interface base object.
546		* @return The ID.
547		*/
548	1x	virtual uint32_t get_id() { return this->id; }
549
550		/**
551		* @brief Evaluate mean - returns empty function for this module.
552		* @param spawners Spawning biomass per time step.
553		* @param ssbzero The biomass at unfished levels.
554		*/
555	!	virtual double evaluate_mean(double spawners, double ssbzero) { return 0; }
556
557		/**
558		* @brief Evaluate recruitment process using the Log--R approach.
559		* @param pos Position index, e.g., which year.
560		*/
561	!	virtual double evaluate_process(size_t pos) {
562	!	fims_popdy::LogR<double> LogR;
563
564	!	return LogR.evaluate_process(pos);
565		}
566
567		#ifdef TMB_MODEL
568
569		template <typename Type>
570	4x	bool add_to_fims_tmb_internal() {
571	4x	std::shared_ptr<fims_info::Information<Type>> info =
572		fims_info::Information<Type>::GetInstance();
573
574	4x	std::shared_ptr<fims_popdy::LogR<Type>> recruitment_process =
575		std::make_shared<fims_popdy::LogR<Type>>();
576
577	4x	recruitment_process->id = this->id;
578
579		// add to Information
580	4x	info->recruitment_process_models[recruitment_process->id] =
581		recruitment_process;
582
583	4x	return true;
584		}
585
586		/**
587		* @brief Adds the parameters to the TMB model.
588		* @return A boolean of true.
589		*/
590	1x	virtual bool add_to_fims_tmb() {
591	1x	this->add_to_fims_tmb_internal<TMB_FIMS_REAL_TYPE>();
592	1x	this->add_to_fims_tmb_internal<TMBAD_FIMS_TYPE>();
593
594	1x	return true;
595		}
596
597		#endif
598		};
599
600		#endif

1		/**
2		* @file fishery_model_base.hpp
3		* @brief Defines the base class for all fishery models within the FIMS
4		* framework.
5		* @copyright This file is part of the NOAA, National Marine Fisheries Service
6		* Fisheries Integrated Modeling System project. See LICENSE in the source
7		* folder for reuse information.
8		*/
9		#ifndef FIMS_MODELS_FISHERY_MODEL_BASE_HPP
10		#define FIMS_MODELS_FISHERY_MODEL_BASE_HPP
11
12		#include "../../common/model_object.hpp"
13		#include "../../common/fims_math.hpp"
14		#include "../../common/fims_vector.hpp"
15		#include "../../population_dynamics/population/population.hpp"
16		/**
17		* @brief The population dynamics of FIMS.
18		*
19		*/
20		namespace fims_popdy {
21
22		/**
23		* @brief Structure to hold dimension information for derived quantities.
24		*/
25		struct DimensionInfo {
26		std::string name; /!< name of the derived quantity /
27		int ndims; /!< number of dimensions /
28		fims::Vector<int> dims; /!< vector of dimensions /
29		fims::Vector<std::string> dim_names; /!< vector of dimension names /
30		fims::Vector<double> se_values_m; /!< final values of the report vector /
31
32		/**
33		* @brief Default constructor for dimension information.
34		*/
35	3016x	DimensionInfo() : ndims(0) {}
36
37		/**
38		* @brief Constructor with parameters.
39		* @param name The name of the derived quantity.
40		* @param dims A vector of integers representing the dimensions.
41		* @param dim_names A vector of strings representing the names of the
42		* dimensions.
43		*/
44	3132x	DimensionInfo(const std::string &name, const fims::Vector<int> &dims,
45		const fims::Vector<std::string> &dim_names)
46	3132x	: name(name), ndims(dims.size()), dims(dims), dim_names(dim_names) {}
47
48		/**
49		* Copy constructor
50		*/
51	1248x	DimensionInfo(const DimensionInfo &other)
52	1248x	: name(other.name),
53	1248x	ndims(other.dims.size()),
54	1248x	dims(other.dims),
55	1248x	dim_names(other.dim_names) {}
56
57		/**
58		* @brief Assignment operator for DimensionInfo.
59		*/
60	3132x	DimensionInfo &operator=(const DimensionInfo &other) {
61	3132x	if (this != &other) {
62	3132x	name = other.name;
63	3132x	ndims = other.ndims;
64	3132x	dims = other.dims;
65	3132x	dim_names = other.dim_names;
66	3132x	se_values_m = other.se_values_m;
67		}
68	3132x	return *this;
69		}
70		};
71
72		/**
73		* @brief FisheryModelBase is a base class for fishery models in FIMS.
74		*
75		*/
76		template <typename Type>
77		class FisheryModelBase : public fims_model_object::FIMSObject<Type> {
78		static uint32_t id_g; /*!< global id where unique id is drawn from for fishery
79		model object*/
80		uint32_t id; /!< unique identifier assigned for fishery model object /
81
82		public:
83		#ifdef TMB_MODEL
84		bool do_reporting =
85		true; /!< flag to control reporting of derived quantities /
86		#endif
87		/**
88		* @brief A string specifying the model type.
89		*
90		*/
91		std::string model_type_m;
92		/**
93		* @brief Unique identifier for the fishery model.
94		*
95		*/
96		std::set<uint32_t> population_ids;
97		/**
98		* @brief A vector of populations in the fishery model.
99		*
100		*/
101		std::vector<std::shared_ptr<fims_popdy::Population<Type>>> populations;
102		/**
103		* @brief A map of fleets in the fishery model, indexed by fleet id.
104		* Unique instances to eliminate duplicate initialization.
105		*
106		*/
107		std::map<uint32_t, std::shared_ptr<fims_popdy::Fleet<Type>>> fleets;
108		/**
109		* @brief Fleet-based iterator.
110		*
111		*/
112		typedef typename std::map<uint32_t,
113		std::shared_ptr<fims_popdy::Fleet<Type>>>::iterator
114		fleet_iterator;
115
116		/**
117		* @brief Type definitions for derived quantities and dimension information
118		* maps.
119		*/
120		typedef typename std::map<uint32_t, std::map<std::string, fims::Vector<Type>>>
121		DerivedQuantitiesMap;
122
123		/**
124		* @brief Iterator for the derived quantities map.
125		*/
126		typedef typename DerivedQuantitiesMap::iterator DerivedQuantitiesMapIterator;
127
128		/**
129		* @brief Shared pointer for the fleet derived quantities map.
130		*/
131		std::shared_ptr<DerivedQuantitiesMap> fleet_derived_quantities;
132
133		/**
134		* @brief Shared pointer for the population derived quantities map.
135		*/
136		std::shared_ptr<DerivedQuantitiesMap> population_derived_quantities;
137
138		/**
139		* @brief Type definitions for dimension information maps.
140		*/
141		typedef typename std::map<uint32_t, std::map<std::string, DimensionInfo>>
142		DimensionInfoMap;
143
144		/**
145		* @brief Shared pointer for the fleet dimension information map.
146		*/
147		std::shared_ptr<DimensionInfoMap> fleet_dimension_info;
148
149		/**
150		* @brief Shared pointer for the population dimension information map.
151		*/
152		std::shared_ptr<DimensionInfoMap> population_dimension_info;
153
154		#ifdef TMB_MODEL
155		::objective_function<Type> *of;
156		#endif
157		/**
158		* @brief Construct a new Fishery Model Base object.
159		*
160		*/
161	116x	FisheryModelBase() : id(FisheryModelBase::id_g++) {
162	116x	fleet_derived_quantities = std::make_shared<DerivedQuantitiesMap>();
163	116x	population_derived_quantities = std::make_shared<DerivedQuantitiesMap>();
164	116x	fleet_dimension_info = std::make_shared<DimensionInfoMap>();
165	116x	population_dimension_info = std::make_shared<DimensionInfoMap>();
166		}
167
168		/**
169		* @brief Construct a new Fishery Model Base object.
170		*
171		* @param other
172		*/
173		FisheryModelBase(const FisheryModelBase &other)
174		: id(other.id),
175		population_ids(other.population_ids),
176		populations(other.populations),
177		fleet_derived_quantities(other.fleet_derived_quantities),
178		population_derived_quantities(other.population_derived_quantities),
179		fleet_dimension_info(other.fleet_dimension_info),
180		population_dimension_info(other.population_dimension_info) {}
181
182		/**
183		* @brief Destroy the Fishery Model Base object.
184		*
185		*/
186	58x	virtual ~FisheryModelBase() {}
187
188		/**
189		* @brief Get the fleet dimension information.
190		*
191		* @return std::map<uint32_t, std::map<std::string, DimensionInfo>>
192		*/
193		std::map<uint32_t, std::map<std::string, DimensionInfo>> &
194		GetFleetDimensionInfo() {
195		return *fleet_dimension_info;
196		}
197
198		/**
199		* @brief Get the population dimension information.
200		*
201		* @return std::map<uint32_t, std::map<std::string, DimensionInfo>>
202		*/
203		std::map<uint32_t, std::map<std::string, DimensionInfo>> &
204		GetPopulationDimensionInfo() {
205		return *population_dimension_info;
206		}
207
208		/**
209		* @brief Get the fleet derived quantities.
210		*
211		* @return DerivedQuantitiesMap
212		*/
213		DerivedQuantitiesMap &GetFleetDerivedQuantities() {
214		return *fleet_derived_quantities;
215		}
216
217		/**
218		* @brief Get the population derived quantities.
219		*
220		* @return DerivedQuantitiesMap
221		*/
222		DerivedQuantitiesMap &GetPopulationDerivedQuantities() {
223		return *population_derived_quantities;
224		}
225
226		/**
227		* @brief Get the fleet derived quantities for a specified fleet.
228		*
229		* @param fleet_id The ID of the fleet.
230		* @return std::map<std::string, fims::Vector<Type>>&
231		*/
232	2367784x	std::map<std::string, fims::Vector<Type>> &GetFleetDerivedQuantities(
233		uint32_t fleet_id) {
234	2367784x	if (!fleet_derived_quantities) {
235	!	throw std::runtime_error(
236		"GetFleetDerivedQuantities: fleet_derived_quantities is null");
237		}
238	2367784x	auto &outer = *fleet_derived_quantities;
239	2367784x	auto it = outer.find(fleet_id);
240	2367784x	if (it == outer.end()) {
241	!	std::stringstream ss;
242
243	!	ss << "GetFleetDerivedQuantities: fleet_id " << fleet_id
244	!	<< " not found in fleet_derived_quantities";
245	!	throw std::out_of_range(ss.str());
246		}
247	4735568x	return it->second;
248		}
249
250		/**
251		* @brief Initialize the derived quantities map for a fleet.
252		*
253		* @details Ensures the derived quantities map for the specified fleet
254		* exists. If not, creates an empty map for the fleet ID.
255		*
256		* @param fleet_id The ID of the fleet to initialize.
257		*/
258	232x	void InitializeFleetDerivedQuantities(uint32_t fleet_id) {
259		// Ensure the shared_ptr exists
260	232x	if (!fleet_derived_quantities) {
261	!	fleet_derived_quantities = std::make_shared<
262		std::map<uint32_t, std::map<std::string, fims::Vector<Type>>>>();
263		}
264
265	232x	auto &outer = *fleet_derived_quantities;
266
267		// Insert only if not already present
268	232x	if (outer.find(fleet_id) == outer.end()) {
269	232x	outer.emplace(fleet_id, std::map<std::string, fims::Vector<Type>>{});
270		}
271		}
272
273		/**
274		* @brief Initialize the derived quantities map for a population.
275		*
276		* @details Ensures the derived quantities map for the specified
277		* population exists. If not, creates an empty map for the population ID.
278		*
279		* @param population_id The ID of the population to initialize.
280		*/
281	116x	void InitializePopulationDerivedQuantities(uint32_t population_id) {
282		// Ensure the shared_ptr exists
283	116x	if (!population_derived_quantities) {
284	!	population_derived_quantities = std::make_shared<
285		std::map<uint32_t, std::map<std::string, fims::Vector<Type>>>>();
286		}
287
288	116x	auto &outer = *population_derived_quantities;
289
290		// Insert only if not already present
291	116x	if (outer.find(population_id) == outer.end()) {
292	116x	outer.emplace(population_id, std::map<std::string, fims::Vector<Type>>{});
293		}
294		}
295
296		/**
297		* @brief Get the population derived quantities for a specified population.
298		*
299		* @param population_id The ID of the population.
300		* @return std::map<std::string, fims::Vector<Type>>&
301		*/
302	2226450x	std::map<std::string, fims::Vector<Type>> &GetPopulationDerivedQuantities(
303		uint32_t population_id) {
304	2226450x	if (!population_derived_quantities) {
305	!	throw std::runtime_error(
306		"GetPopulationDerivedQuantities: population_derived_quantities is "
307		"null");
308		}
309	2226450x	auto &outer = *population_derived_quantities;
310	2226450x	auto it = outer.find(population_id);
311	2226450x	if (it == outer.end()) {
312	!	std::ostringstream ss;
313	!	ss << "GetPopulationDerivedQuantities: population_id " << population_id
314	!	<< " not found in population_derived_quantities";
315	!	throw std::out_of_range(ss.str());
316		}
317	4452900x	return it->second;
318		}
319
320		/**
321		* @brief Get the fleet dimension information for a specified fleet.
322		*
323		* @param fleet_id The ID of the fleet.
324		* @return std::map<std::string, DimensionInfo>
325		*/
326	328x	std::map<std::string, DimensionInfo> &GetFleetDimensionInfo(
327		uint32_t fleet_id) {
328	328x	return (*fleet_dimension_info)[fleet_id];
329		}
330
331		/**
332		* @brief Get the population dimension information for a specified population.
333		*
334		* @param population_id The ID of the population.
335		* @return std::map<std::string, DimensionInfo>
336		*/
337	164x	std::map<std::string, DimensionInfo> &GetPopulationDimensionInfo(
338		uint32_t population_id) {
339	164x	return (*population_dimension_info)[population_id];
340		}
341
342		/**
343		* @brief Initialize a model.
344		*
345		*/
346	!	virtual void Initialize() {}
347
348		/**
349		* @brief Prepare the model.
350		*
351		*/
352	!	virtual void Prepare() {}
353
354		/**
355		* @brief Reset a vector from start to end with a value.
356		*
357		* @param v A vector to reset.
358		* @param value The value you want to use for all elements in the
359		* vector. The default is 0.0.
360		*/
361	54912x	virtual void ResetVector(fims::Vector<Type> &v, Type value = 0.0) {
362	54912x	std::fill(v.begin(), v.end(), value);
363		}
364
365		/**
366		* @brief Evaluate the model.
367		*
368		*/
369	!	virtual void Evaluate() {}
370
371		/**
372		* @brief Report the model results via TMB.
373		*
374		*/
375	!	virtual void Report() {}
376
377		/**
378		* @brief Get the Id object.
379		*
380		* @return uint32_t
381		*/
382	116x	uint32_t GetId() { return this->id; }
383		};
384
385		template <typename Type>
386		uint32_t FisheryModelBase<Type>::id_g = 0;
387
388		} // namespace fims_popdy
389		#endif

1		/**
2		* @file fleet.hpp
3		* @brief Declare the fleet functor class which is the base class for all fleet
4		* functors.
5		* @copyright This file is part of the NOAA, National Marine Fisheries Service
6		* Fisheries Integrated Modeling System project. See LICENSE in the source
7		* folder for reuse information.
8		*/
9		#ifndef FIMS_POPULATION_DYNAMICS_FLEET_HPP
10		#define FIMS_POPULATION_DYNAMICS_FLEET_HPP
11
12		#include "../../common/data_object.hpp"
13		#include "../../common/fims_vector.hpp"
14		#include "../../common/model_object.hpp"
15		#include "../../distributions/distributions.hpp"
16		#include "../selectivity/selectivity.hpp"
17
18		namespace fims_popdy {
19
20		/** @brief Base class for all fleets.
21		*
22		* @tparam Type The type of the fleet object.
23		*/
24		template <class Type>
25		struct Fleet : public fims_model_object::FIMSObject<Type> {
26		static uint32_t id_g; /!< reference id for fleet object/
27		size_t n_years; /!< the number of years in the model/
28		size_t n_ages; /!< the number of ages in the model/
29		size_t n_lengths; /!< the number of lengths in the model/
30
31		// selectivity
32		int fleet_selectivity_id_m = -999; /!< id of selectivity component/
33		std::shared_ptr<SelectivityBase<Type>>
34		selectivity; /!< selectivity component/
35
36		// landings data
37		int fleet_observed_landings_data_id_m = -999; /!< id of landings data /
38		std::shared_ptr<fims_data_object::DataObject<Type>>
39		observed_landings_data; /!< observed landings data/
40
41		std::string observed_landings_units; /!< is this fleet landings in weight/
42
43		// index data
44		int fleet_observed_index_data_id_m = -999; /!< id of index data /
45		std::shared_ptr<fims_data_object::DataObject<Type>>
46		observed_index_data; /!< observed index data/
47
48		std::string observed_index_units; /!< is this fleet index in weight/
49
50		// age comp data
51		int fleet_observed_agecomp_data_id_m = -999; /!< id of age comp data /
52		std::shared_ptr<fims_data_object::DataObject<Type>>
53		observed_agecomp_data; /!< observed agecomp data/
54
55		// length comp data
56		int fleet_observed_lengthcomp_data_id_m = -999; /!< id of length comp data /
57		std::shared_ptr<fims_data_object::DataObject<Type>>
58		observed_lengthcomp_data; /!< observed lengthcomp data/
59
60		// Mortality and catchability
61		fims::Vector<Type>
62		log_Fmort; /!< estimated parameter: log Fishing mortality/
63		fims::Vector<Type>
64		log_q; /!< estimated parameter: catchability of the fleet /
65
66		fims::Vector<Type> Fmort; /!< transformed parameter: Fishing mortality/
67		fims::Vector<Type>
68		q; /!< transformed parameter: the catchability of the fleet /
69
70		fims::Vector<Type> age_to_length_conversion; /*!<derived quantity age to
71		length conversion matrix*/
72
73		/**
74		* @brief Constructor.
75		*/
76	244x	Fleet() { this->id = Fleet::id_g++; }
77
78		/**
79		* @brief Destructor.
80		*/
81	122x	virtual ~Fleet() {}
82
83		/**
84		* @brief Prepare to run the fleet module. Called at each model
85		* iteration, and used to exponentiate the natural log of q and Fmort
86		* parameters prior to evaluation.
87		*
88		*/
89		void Prepare() {
90		// for(size_t fleet_ = 0; fleet_ <= this->n_fleets; fleet_++) {
91		// this -> Fmort[fleet_] = fims_math::exp(this -> log_Fmort[fleet_]);
92
93		for (size_t i = 0; i < this->log_q.size(); i++) {
94		this->q[i] = fims_math::exp(this->log_q[i]);
95		}
96
97		for (size_t year = 0; year < this->n_years; year++) {
98		this->Fmort[year] = fims_math::exp(this->log_Fmort[year]);
99		}
100		}
101		};
102
103		// default id of the singleton fleet class
104		template <class Type>
105		uint32_t Fleet<Type>::id_g = 0;
106
107		} // end namespace fims_popdy
108
109		#endif /* FIMS_POPULATION_DYNAMICS_FLEET_HPP */

1		/**
2		* @file ewaa.hpp
3		* @brief Defines the EWAAGrowth class, which inherits from the GrowthBase
4		* class.
5		* @copyright This file is part of the NOAA, National Marine Fisheries Service
6		* Fisheries Integrated Modeling System project. See LICENSE in the source
7		* folder for reuse information.
8		*/
9		#ifndef POPULATION_DYNAMICS_GROWTH_EWAA_HPP
10		#define POPULATION_DYNAMICS_GROWTH_EWAA_HPP
11
12		// #include "../../../interface/interface.hpp"
13		#include <map>
14
15		#include "growth_base.hpp"
16
17		namespace fims_popdy {
18
19		/**
20		* @brief EWAAGrowth class that returns the EWAA function value.
21		*/
22		template <typename Type>
23		struct EWAAGrowth : public GrowthBase<Type> {
24		// add submodule class members here
25		// these include parameters of the submodule
26		// a map looks up values based on a reference key
27		// in this case, our key is age (first double), and
28		// the value is the weight at that age (second double)
29		std::map<int, std::map<double, double>> ewaa; /**<map of doubles for EWAA values by age,
30		where age starts at zero > */
31		typedef typename std::map<double, double>::iterator
32		weight_iterator; /*< Iterator for ewaa map object > /
33
34	126x	EWAAGrowth() : GrowthBase<Type>() {}
35
36	63x	virtual ~EWAAGrowth() {}
37
38		/**
39		* @brief Returns the weight at age a (in kg) from the input vector.
40		*
41		* @param year year
42		* @param a age of the fish, the age vector must start at zero
43		*/
44	897733x	virtual const Type evaluate(int year, const double& a) {
45	897733x	return this->ewaa[year][a];
46		}
47		};
48		} // namespace fims_popdy
49		#endif /* POPULATION_DYNAMICS_GROWTH_EWAA_HPP */

1		/**
2		* @file growth_base.hpp
3		* @brief Declares the GrowthBase class which is the base class for all growth
4		* functors.
5		* @details Defines guards for growth module outline to define the
6		* module_name_base hpp file if not already defined.
7		* @copyright This file is part of the NOAA, National Marine Fisheries Service
8		* Fisheries Integrated Modeling System project. See LICENSE in the source
9		* folder for reuse information.
10		*/
11		#ifndef POPULATION_DYNAMICS_GROWTH_BASE_HPP
12		#define POPULATION_DYNAMICS_GROWTH_BASE_HPP
13
14		#include "../../../common/model_object.hpp"
15
16		namespace fims_popdy {
17
18		/**
19		* @brief Base class for all growth functors.
20		*
21		* @tparam Type The type of the growth functor.
22		*/
23		template <typename Type>
24		struct GrowthBase : public fims_model_object::FIMSObject<Type> {
25		// id_g is the ID of the instance of the growthBase class.
26		// this is like a memory tracker.
27		// Assigning each one its own ID is a way to keep track of
28		// all the instances of the growthBase class.
29		static uint32_t id_g; /*< reference id for growth object/
30
31		/**
32		* @brief Constructor.
33		*/
34	126x	GrowthBase() { this->id = GrowthBase::id_g++; }
35
36	63x	virtual ~GrowthBase() {}
37
38		/**
39		* @brief Calculates the growth at the independent variable value.
40		* @param year The year at which to return weight of the fish (in kg).
41		* @param a The age at which to return weight of the fish (in kg).
42		*/
43		virtual const Type evaluate(int year, const double& a) = 0;
44		};
45
46		template <typename Type>
47		uint32_t GrowthBase<Type>::id_g = 0;
48
49		} // namespace fims_popdy
50
51		#endif /* POPULATION_DYNAMICS_GROWTH_BASE_HPP */

1		/**
2		* @file logistic.hpp
3		* @brief Defines the LogisticMaturity class, which inherits from the
4		* MaturityBase class.
5		* @copyright This file is part of the NOAA, National Marine Fisheries Service
6		* Fisheries Integrated Modeling System project. See LICENSE in the source
7		* folder for reuse information.
8		*
9		*/
10		#ifndef POPULATION_DYNAMICS_MATURITY_LOGISTIC_HPP
11		#define POPULATION_DYNAMICS_MATURITY_LOGISTIC_HPP
12
13		#include "../../../common/fims_math.hpp"
14		#include "../../../common/fims_vector.hpp"
15		#include "maturity_base.hpp"
16
17		namespace fims_popdy {
18
19		/**
20		* @brief LogisticMaturity class that returns the logistic function value
21		* from fims_math.
22		*/
23		template <typename Type>
24		struct LogisticMaturity : public MaturityBase<Type> {
25		fims::Vector<Type>
26		inflection_point; /**< 50 percent quantile of the value of the quantity of
27		interest (x); e.g. age at which 50 percent of the fish are mature */
28		fims::Vector<Type> slope; /**<scalar multiplier of difference between quantity
29		of interest value (x) and inflection_point */
30
31	122x	LogisticMaturity() : MaturityBase<Type>() {}
32
33		/**
34		* @brief Method of the logistic maturity class that implements the
35		* logistic function from FIMS math.
36		*
37		* \f[ \frac{1.0}{ 1.0 + exp(-1.0 * slope (x - inflection_point))} \f]
38		*
39		* @param x The independent variable in the logistic function (e.g., age or
40		* size at maturity).
41		*/
42
43	203018x	virtual const Type evaluate(const Type& x) {
44	203018x	return fims_math::logistic<Type>(inflection_point[0], slope[0], x);
45		}
46
47		/**
48		* @brief Method of the logistic maturity class that implements the
49		* logistic function from FIMS math.
50		*
51		* \f[ \frac{1.0}{ 1.0 + exp(-1.0 * slope_t (x - {inflection\_point}_t))} \f]
52		*
53		* @param x The independent variable in the logistic function (e.g., age or
54		* size in selectivity).
55		* @param pos Position index, e.g., which year.
56		*/
57	!	virtual const Type evaluate(const Type& x, size_t pos) {
58	!	return fims_math::logistic<Type>(inflection_point.get_force_scalar(pos),
59	!	slope.get_force_scalar(pos), x);
60		}
61		};
62
63		} // namespace fims_popdy
64
65		#endif /* POPULATION_DYNAMICS_MATURITY_LOGISTIC_HPP */

1		/**
2		* @file maturity_base.hpp
3		* @brief Declares the MaturityBase class which is the base class for all
4		* maturity functors.
5		* @details Defines guards for maturity module outline to define the maturity
6		* hpp file if not already defined.
7		* @copyright This file is part of the NOAA, National Marine Fisheries Service
8		* Fisheries Integrated Modeling System project. See LICENSE in the source
9		* folder for reuse information.
10		*/
11		#ifndef POPULATION_DYNAMICS_MATURITY_BASE_HPP
12		#define POPULATION_DYNAMICS_MATURITY_BASE_HPP
13
14		#include "../../../common/model_object.hpp"
15
16		namespace fims_popdy {
17
18		/** @brief Base class for all maturity functors.
19		*
20		* @tparam Type The type of the maturity functor.
21		*/
22
23		template <typename Type>
24		struct MaturityBase : public fims_model_object::FIMSObject<Type> {
25		// id_g is the ID of the instance of the MaturityBase class.
26		// this is like a memory tracker.
27		// Assigning each one its own ID is a way to keep track of
28		// all the instances of the MaturityBase class.
29		static uint32_t id_g; /*< The ID of the instance of the MaturityBase class /
30
31		/** @brief Constructor.
32		*/
33	122x	MaturityBase() {
34		// increment id of the singleton maturity class
35	122x	this->id = MaturityBase::id_g++;
36		}
37
38		/**
39		* @brief Calculates the maturity.
40		* @param x The independent variable in the maturity function (e.g., logistic
41		* maturity at age or size).
42		*/
43		virtual const Type evaluate(const Type& x) = 0;
44		/**
45		* @brief Calculates the selectivity.
46		* @param x The independent variable in the logistic function (e.g., age or
47		* size in selectivity).
48		* @param pos Position index, e.g., which year.
49		*/
50		virtual const Type evaluate(const Type& x, size_t pos) = 0;
51		};
52
53		// default id of the singleton maturity class
54		template <typename Type>
55		uint32_t MaturityBase<Type>::id_g = 0;
56
57		} // namespace fims_popdy
58
59		#endif /* POPULATION_DYNAMICS_MATURITY_BASE_HPP */