cable_output_variable_t Derived Type

type, public :: cable_output_variable_t

Type for describing output variables.

This type provides the basis for registering output variables with the output module via cable_output_register_output_variables, and is used in the definition and writing of output variables in various output streams.


Components

Type Visibility Attributes Name Initial
character(len=64), public :: field_name

The name of the variable as used in the CABLE code. This name is used as the netCDF variable name when writing CABLE restart files.
character(len=64), public :: netcdf_name = ""

The name of the variable as it should appear in netCDF output files. If not specified, this defaults to field_name.
character(len=64), public :: accumulation_frequency = "all"

The frequency at which the variable is accumulated when computing time aggregations. Please refer to the cable_timing_frequency_matches procedure for more information on the available frequency settings. If not specified, this defaults to "all", meaning that the variable is accumulated at every CABLE time step.
character(len=64), public :: reduction_method = "none"

The grid cell reduction method to apply to the variable. The allowed reduction methods are specified in allowed_reduction_methods. Please refer to cable_grid_reductions_mod for more details on grid reductions.
character(len=64), public :: aggregation_method = "point"

The time aggregation method to apply when sampling a diagnostic. Please refer to allowed_aggregation_methods for more details on the available aggregation methods.
logical, public :: active = .true.

A flag indicating whether the variable is active in the default output stream.
logical, public :: parameter = .false.

A flag indicating whether the variable is a non-time varying parameter. Variables with parameter = .true. are written once on the first time step via cable_output_write_parameters.
logical, public :: distributed = .true.

A flag indicating whether the variable is distributed across multiple processes. If distributed = .true., the output module will infer an appropriate parallel I/O decomposition from data_shape to perform a distributed write to disk. If distributed = .false., it is assumed by the output module that each process has a copy of the data, and only the data on the root process will be written.
logical, public :: restart = .false.

A flag indicating whether the variable should be written to the CABLE restart file at the end of the run. Please see cable_output_write_restart for more details on how restart variables are written.
logical, public :: patchout = .false.

A flag indicating whether subgrid patch information should be included in the output variable output. If patchout = .true., this has the same effect as setting reduction_method = "none". This is a legacy flag for backward compatibility with the CABLE output namelist settings.
integer, public :: var_type = CABLE_OUTPUT_VAR_TYPE_UNDEFINED

The netCDF variable type using CABLE_NETCDF_<type> constants. If not specified, the output module will use the native type of the data as the netCDF variable type.
real, public :: scale_by = 1.0

A multiplicative factor to apply to the native diagnostic values when writing output.
real, public :: divide_by = 1.0

A divisional factor to apply to the native diagnostic values when writing output.
real, public :: offset_by = 0.0

An additive offset to apply to the native diagnostic values when writing output.
real, private :: range_native(2) = [-huge(0.0), huge(0.0)]

The valid range of physical values for the output variable in the units of the native diagnostic.
real, public, allocatable :: range(:)

The valid range of physical values for the output variable. If a unit conversion is applied to the native diagnostic via the scale_by, divide_by, or offset_by components, the range should be given in the units of the output variable after applying the unit conversion. If unspecified, all values are considered valid.
type(cable_output_dim_t), public, allocatable :: data_shape(:)

An array of in-memory dimensions describing the shape of the variable data. The dimensions must be created via cable_output_get_dimension to ensure that reserved dimension names are handled correctly by the output module. If not specified, the data shape is assumed to be a scalar.
class(aggregator_t), public, allocatable :: aggregator

The aggregator object associated with the diagnostic working variable to be written for this output variable. The aggregator object should not be initialised when registering output variables as this is done internally in the output module the output variable is active.
type(cable_output_attribute_t), public, allocatable :: metadata(:)

NetCDF variable attributes to be written with the variable.

Constructor

public interface cable_output_variable_t

  • private function cable_output_variable_constructor(field_name, aggregator, netcdf_name, accumulation_frequency, reduction_method, aggregation_method, active, parameter, distributed, restart, patchout, var_type, scale_by, divide_by, offset_by, range, data_shape, metadata) result(this)

    Custom constructor for cable_output_variable_t.

    This is a work-around for older gfortran compilers < 14 which require allocating polymorphic components, like aggregator, before assignment, which prevents the use of the default constructor for cable_output_variable_t with the aggregator argument.

    Arguments

    Type IntentOptional Attributes Name
    character(len=*), intent(in) :: field_name
    class(aggregator_t), intent(in) :: aggregator
    character(len=*), intent(in), optional :: netcdf_name
    character(len=*), intent(in), optional :: accumulation_frequency
    character(len=*), intent(in), optional :: reduction_method
    character(len=*), intent(in), optional :: aggregation_method
    logical, intent(in), optional :: active
    logical, intent(in), optional :: parameter
    logical, intent(in), optional :: distributed
    logical, intent(in), optional :: restart
    logical, intent(in), optional :: patchout
    integer, intent(in), optional :: var_type
    real, intent(in), optional :: scale_by
    real, intent(in), optional :: divide_by
    real, intent(in), optional :: offset_by
    real, intent(in), optional :: range(:)
    type(cable_output_dim_t), intent(in), optional :: data_shape(:)
    type(cable_output_attribute_t), intent(in), optional :: metadata(:)

    Return Value type(cable_output_variable_t)


Type-Bound Procedures

procedure, private :: get_netcdf_name => cable_output_variable_get_netcdf_name

Return the netCDF variable name, which defaults to field_name if not specified via netcdf_name.

  • private elemental function cable_output_variable_get_netcdf_name(this) result(netcdf_name)

    Return the netCDF variable name, which defaults to field_name if not specified via netcdf_name.

    Arguments

    Type IntentOptional Attributes Name
    class(cable_output_variable_t), intent(in) :: this

    Return Value character(len=64)