calliope.backend.backend_model.BackendModel(inputs, math, instance, **kwargs)

Bases: BackendModelGenerator, Generic[T]

Calliope's backend model functionality.

Abstract base class to build backend models that interface with solvers.

Parameters:

Name	Type	Description	Default
inputs	Dataset	Calliope model data.	required
math	CalliopeMath	Calliope math.	required
instance	T	Interface model instance.	required
**kwargs		build configuration overrides.	{}

Source code in src/calliope/backend/backend_model.py

def __init__(
    self, inputs: xr.Dataset, math: CalliopeMath, instance: T, **kwargs
) -> None:
    """Abstract base class to build backend models that interface with solvers.

    Args:
        inputs (xr.Dataset): Calliope model data.
        math (CalliopeMath): Calliope math.
        instance (T): Interface model instance.
        **kwargs: build configuration overrides.
    """
    super().__init__(inputs, math, **kwargs)
    self._instance = instance
    self.shadow_prices: ShadowPrices
    self._has_verbose_strings: bool = False

LID_COMPONENTS: tuple[ALL_COMPONENTS_T, ...] = typing.get_args(ALL_COMPONENTS_T) class-attribute instance-attribute

constraints property

Slice of backend dataset to show only built constraints.

global_expressions property

Slice of backend dataset to show only built global expressions.

has_integer_or_binary_variables: bool abstractmethod property

Confirms if the built model has binary or integer decision variables.

This can be used to understand how long the optimisation may take (MILP problems are harder to solve than LP ones), and to verify whether shadow prices can be tracked (they cannot be tracked in MILP problems).

Returns:

Name	Type	Description
bool	bool	True if the built model has binary or integer decision variables. False if all decision variables are continuous.

inputs = inputs.copy() instance-attribute

math: CalliopeMath = deepcopy(math) instance-attribute

objectives property

Slice of backend dataset to show only built objectives.

parameters property

Slice of backend dataset to show only built parameters.

piecewise_constraints property

Slice of backend dataset to show only built piecewise constraints.

shadow_prices: ShadowPrices instance-attribute

valid_component_names: set property

Return a set of valid component names in the model data.

Returns:

Name	Type	Description
set	set	set of valid names.

variables property

Slice of backend dataset to show only built variables.

add_constraint(name, constraint_dict) abstractmethod

Add constraint equation to backend model in-place.

Resulting backend dataset entries will be constraint objects.

Parameters:

Name	Type	Description	Default
name	str	Name of the constraint	required
constraint_dict	UnparsedConstraint	Constraint configuration dictionary, ready to be parsed and then evaluated.	required

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def add_constraint(
    self, name: str, constraint_dict: parsing.UnparsedConstraint
) -> None:
    """Add constraint equation to backend model in-place.

    Resulting backend dataset entries will be constraint objects.

    Args:
        name (str):
            Name of the constraint
        constraint_dict (parsing.UnparsedConstraint):
            Constraint configuration dictionary, ready to be parsed and then evaluated.
    """

add_global_expression(name, expression_dict) abstractmethod

Add global expression (arithmetic combination of parameters and/or decision variables) to backend model in-place.

Resulting backend dataset entries will be linear expression objects.

Parameters:

Name	Type	Description	Default
name	str	name of the global expression	required
expression_dict	UnparsedExpression	Global expression configuration dictionary, ready to be parsed and then evaluated.	required

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def add_global_expression(
    self, name: str, expression_dict: parsing.UnparsedExpression
) -> None:
    """Add global expression (arithmetic combination of parameters and/or decision variables) to backend model in-place.

    Resulting backend dataset entries will be linear expression objects.

    Args:
        name (str): name of the global expression
        expression_dict (parsing.UnparsedExpression): Global expression configuration dictionary, ready to be parsed and then evaluated.
    """

add_objective(name, objective_dict) abstractmethod

Add objective arithmetic to backend model in-place.

Resulting backend dataset entry will be a single, unindexed objective object.

Parameters:

Name	Type	Description	Default
name	str	name of the objective.	required
objective_dict	UnparsedObjective	Unparsed objective configuration dictionary.	required

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def add_objective(
    self, name: str, objective_dict: parsing.UnparsedObjective
) -> None:
    """Add objective arithmetic to backend model in-place.

    Resulting backend dataset entry will be a single, unindexed objective object.

    Args:
        name (str): name of the objective.
        objective_dict (parsing.UnparsedObjective): Unparsed objective configuration dictionary.
    """

add_optimisation_components()

Parse math and inputs and set optimisation problem.

Source code in src/calliope/backend/backend_model.py

def add_optimisation_components(self) -> None:
    """Parse math and inputs and set optimisation problem."""
    # The order of adding components matters!
    # 1. Variables, 2. Global Expressions, 3. Constraints, 4. Objectives
    self._add_all_inputs_as_parameters()
    if self.inputs.attrs["config"]["build"]["pre_validate_math_strings"]:
        self._validate_math_string_parsing()
    for components in typing.get_args(ORDERED_COMPONENTS_T):
        component = components.removesuffix("s")
        for name, dict_ in self.math.data[components].items():
            start = time.time()
            getattr(self, f"add_{component}")(name, dict_)
            end = time.time() - start
            LOGGER.debug(
                f"Optimisation Model | {components}:{name} | Built in {end:.4f}s"
            )
        LOGGER.info(f"Optimisation Model | {components} | Generated.")

add_parameter(parameter_name, parameter_values, default=np.nan) abstractmethod

Add input parameter to backend model in-place.

If the backend interface allows for mutable parameter objects, they will be generated, otherwise a copy of the model input dataset will be used. In either case, NaN values are filled with the given parameter default value.

Parameters:

Name	Type	Description	Default
parameter_name	str	Name of parameter.	required
parameter_values	DataArray	Array of parameter values.	required
default	Any	Default value to fill NaN entries in parameter values array. Defaults to np.nan.	nan

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def add_parameter(
    self, parameter_name: str, parameter_values: xr.DataArray, default: Any = np.nan
) -> None:
    """Add input parameter to backend model in-place.

    If the backend interface allows for mutable parameter objects, they will be
    generated, otherwise a copy of the model input dataset will be used.
    In either case, NaN values are filled with the given parameter default value.

    Args:
        parameter_name (str): Name of parameter.
        parameter_values (xr.DataArray): Array of parameter values.
        default (Any, optional):
            Default value to fill NaN entries in parameter values array.
            Defaults to np.nan.
    """

add_piecewise_constraint(name, constraint_dict)

Source code in src/calliope/backend/backend_model.py

def add_piecewise_constraint(  # noqa: D102, override
    self, name: str, constraint_dict: parsing.UnparsedPiecewiseConstraint
) -> None:
    if "breakpoints" in constraint_dict.get("foreach", []):
        raise BackendError(
            f"(piecewise_constraints, {name}) | `breakpoints` dimension should not be in `foreach`. "
            "Instead, index `x_values` and `y_values` parameters over `breakpoints`."
        )

    def _constraint_setter(where: xr.DataArray, references: set) -> xr.DataArray:
        expressions = []
        vals = []
        for axis in ["x", "y"]:
            expression_name = constraint_dict[f"{axis}_expression"]  # type: ignore
            parsed_component = parsing.ParsedBackendComponent(  # type: ignore
                "piecewise_constraints",
                name,
                {"equations": [{"expression": expression_name}], **constraint_dict},
            )
            eq = parsed_component.parse_equations(self.valid_component_names)
            expression_da = eq[0].evaluate_expression(
                self, where=where, references=references
            )
            val_name = constraint_dict[f"{axis}_values"]  # type: ignore
            val_da = self.get_parameter(val_name)
            if "breakpoints" not in val_da.dims:
                raise BackendError(
                    f"(piecewise_constraints, {name}) | "
                    f"`{axis}_values` must be indexed over the `breakpoints` dimension."
                )
            references.add(val_name)
            expressions.append(expression_da)
            vals.extend([*val_da.to_dataset("breakpoints").data_vars.values()])
        try:
            return self._apply_func(
                self._to_piecewise_constraint,
                where,
                1,
                *expressions,
                *vals,
                name=name,
                n_breakpoints=len(self.inputs.breakpoints),
            )
        except BackendError as err:
            raise BackendError(
                f"(piecewise_constraints, {name}) | Errors in generating piecewise constraint: {err}"
            )

    self._add_component(
        name, constraint_dict, _constraint_setter, "piecewise_constraints"
    )

add_variable(name, variable_dict) abstractmethod

Add decision variable to backend model in-place.

Resulting backend dataset entries will be decision variable objects.

Parameters:

Name	Type	Description	Default
name	str	name of the variable.	required
variable_dict	UnparsedVariable	Unparsed variable configuration dictionary.	required

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def add_variable(self, name: str, variable_dict: parsing.UnparsedVariable) -> None:
    """Add decision variable to backend model in-place.

    Resulting backend dataset entries will be decision variable objects.

    Args:
        name (str): name of the variable.
        variable_dict (parsing.UnparsedVariable): Unparsed variable configuration dictionary.
    """

delete_component(key, component_type) abstractmethod

Delete a list object from the backend model object.

Parameters:

Name	Type	Description	Default
key	str	Name of object.	required
component_type	str	Object type.	required

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def delete_component(self, key: str, component_type: ALL_COMPONENTS_T) -> None:
    """Delete a list object from the backend model object.

    Args:
        key (str): Name of object.
        component_type (str): Object type.
    """

fix_variable(name, where=None) abstractmethod

Fix the variable value to the value quantified on the most recent call to solve.

Fixed variables will be treated as parameters in the optimisation.

Parameters:

Name	Type	Description	Default
name	str	Variable to update.	required
where	DataArray | None	If provided, only a subset of the coordinates in the variable will be fixed. Must be a boolean array or a float equivalent, where NaN is used instead of False. Defaults to None	None

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def fix_variable(self, name: str, where: xr.DataArray | None = None) -> None:
    """Fix the variable value to the value quantified on the most recent call to `solve`.

    Fixed variables will be treated as parameters in the optimisation.

    Args:
        name (str): Variable to update.
        where (xr.DataArray | None, optional):
            If provided, only a subset of the coordinates in the variable will be fixed.
            Must be a boolean array or a float equivalent, where NaN is used instead of False.
            Defaults to None
    """

get_constraint(name, as_backend_objs=True, eval_body=False) abstractmethod

get_constraint(name: str, as_backend_objs: Literal[True] = True, eval_body: bool = False) -> xr.DataArray

get_constraint(name: str, as_backend_objs: Literal[False], eval_body: bool = False) -> xr.Dataset

Get constraint data from the backend for debugging.

Dat can be returned as a table of details or as an array of backend interface objects

Parameters:

Name	Type	Description	Default
name	str	Name of constraint, as given in YAML constraint key.	required
as_backend_objs	bool	TODO: hide this and create a method to edit constraints that handles differences in interface APIs If True, will keep the array entries as backend interface objects, which can be updated to change the underlying model. Otherwise, constraint body, and lower and upper bounds are given in a table. Defaults to True.	True
eval_body	bool	If True and as_backend_objs is False, will attempt to evaluate the constraint body. If the model has been optimised, this attempt will produce a numeric value to see where the constraint sits between the lower or upper bound. If the model has not yet been optimised, this attempt will fall back on the same as if eval_body was set to False, i.e. a string representation of the linear expression in the constraint body. Defaults to False.	False

Returns:

Type	Description
DataArray | Dataset	xr.DataArray | xr.Dataset: If as_backend_objs is True, will return an xr.DataArray. Otherwise, a xr.Dataset will be given, indexed over the same dimensions as the xr.DataArray, with variables for the constraint body, and upper (ub) and lower (lb) bounds.

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def get_constraint(
    self, name: str, as_backend_objs: bool = True, eval_body: bool = False
) -> xr.DataArray | xr.Dataset:
    """Get constraint data from the backend for debugging.

    Dat can be returned as  a table of details or as an array of backend interface objects

    Args:
        name (str): Name of constraint, as given in YAML constraint key.
        as_backend_objs (bool, optional): TODO: hide this and create a method to edit constraints that handles differences in interface APIs
            If True, will keep the array entries as backend interface objects,
            which can be updated to change the underlying model.
            Otherwise, constraint body, and lower and upper bounds are given in a table.
            Defaults to True.
        eval_body (bool, optional):
            If True and as_backend_objs is False, will attempt to evaluate the constraint body.
            If the model has been optimised, this attempt will produce a numeric value to see where the constraint sits between the lower or upper bound.
            If the model has not yet been optimised, this attempt will fall back on the same as
            if `eval_body` was set to False, i.e. a string representation of the linear expression in the constraint body.
            Defaults to False.

    Returns:
        xr.DataArray | xr.Dataset:
            If as_backend_objs is True, will return an xr.DataArray.
            Otherwise, a xr.Dataset will be given, indexed over the same dimensions as the xr.DataArray, with variables for the constraint body, and upper (`ub`) and lower (`lb`) bounds.
    """

get_global_expression(name, as_backend_objs=True, eval_body=True) abstractmethod

Extract global expression array from backend dataset.

Parameters:

Name	Type	Description	Default
name	str	Name of global expression	required
as_backend_objs	bool	TODO: hide this and create a method to edit expressions that handles differences in interface APIs. If True, will keep the array entries as backend interface objects, which can be updated to update the underlying model. Otherwise, global expression values are given directly. If the model has not been successfully optimised, expression values will all be provided as strings. Defaults to True.	True
eval_body	bool	If True and as_backend_objs is False, will attempt to evaluate the expression. If the model has been optimised, this attempt will produce a numeric value. If the model has not yet been optimised, this attempt will fall back on the same as if eval_body was set to False, i.e. a string representation of the linear expression. Defaults to True.	True

Returns:

Type	Description
DataArray	xr.DataArray: global expression array.

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def get_global_expression(
    self, name: str, as_backend_objs: bool = True, eval_body: bool = True
) -> xr.DataArray:
    """Extract global expression array from backend dataset.

    Args:
        name (str): Name of global expression
        as_backend_objs (bool, optional): TODO: hide this and create a method to edit expressions that handles differences in interface APIs.
            If True, will keep the array entries as backend interface objects,
            which can be updated to update the underlying model.
            Otherwise, global expression values are given directly.
            If the model has not been successfully optimised, expression values will all be provided as strings.
            Defaults to True.
        eval_body (bool, optional):
            If True and as_backend_objs is False, will attempt to evaluate the expression.
            If the model has been optimised, this attempt will produce a numeric value.
            If the model has not yet been optimised, this attempt will fall back on the same as
            if `eval_body` was set to False, i.e. a string representation of the linear expression.
            Defaults to True.

    Returns:
        xr.DataArray: global expression array.
    """

get_parameter(name, as_backend_objs=True) abstractmethod

Extract parameter from backend dataset.

Parameters:

Name	Type	Description	Default
name	str	Name of parameter.	required
as_backend_objs	bool	TODO: hide this and create a method to edit parameter values (to handle interfaces with non-mutable params) If True, will keep the array entries as backend interface objects, which can be updated to update the underlying model. Otherwise, parameter values are given directly, with default values in place of NaNs. Defaults to True.	True

Returns:

Type	Description
DataArray	xr.DataArray: parameter array.

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def get_parameter(self, name: str, as_backend_objs: bool = True) -> xr.DataArray:
    """Extract parameter from backend dataset.

    Args:
        name (str): Name of parameter.
        as_backend_objs (bool, optional): TODO: hide this and create a method to edit parameter values (to handle interfaces with non-mutable params)
            If True, will keep the array entries as backend interface objects,
            which can be updated to update the underlying model.
            Otherwise, parameter values are given directly, with default values in place of NaNs.
            Defaults to True.

    Returns:
        xr.DataArray: parameter array.
    """

get_piecewise_constraint(name)

Get piecewise constraint data as an array of backend interface objects.

This method can be used to inspect and debug built piecewise constraints.

Unlike other optimisation problem components, piecewise constraints can only be inspected as backend interface objects. This is because each element is a collection of variables, parameters, constraints, and expressions.

Parameters:

Name	Type	Description	Default
name	str	Name of piecewise constraint, as given in YAML piecewise constraint key.	required

Returns:

Type	Description
DataArray	xr.DataArray: Piecewise constraint array.

Source code in src/calliope/backend/backend_model.py

def get_piecewise_constraint(self, name: str) -> xr.DataArray:
    """Get piecewise constraint data as an array of backend interface objects.

    This method can be used to inspect and debug built piecewise constraints.

    Unlike other optimisation problem components, piecewise constraints can only be inspected as backend interface objects.
    This is because each element is a collection of variables, parameters, constraints, and expressions.

    Args:
        name (str): Name of piecewise constraint, as given in YAML piecewise constraint key.

    Returns:
        xr.DataArray: Piecewise constraint array.
    """
    return self._get_component(name, "piecewise_constraints")

get_variable(name, as_backend_objs=True) abstractmethod

Extract decision variable array from backend dataset.

Parameters:

Name	Type	Description	Default
name	str	Name of variable.	required
as_backend_objs	bool	TODO: hide this and create a method to edit variables that handles differences in interface APIs. If True, will keep the array entries as backend interface objects, which can be updated to update the underlying model. Otherwise, variable values are given directly. If the model has not been successfully optimised, variable values will all be None. Defaults to True.	True

Returns:

Type	Description
DataArray	xr.DataArray: Decision variable array.

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def get_variable(self, name: str, as_backend_objs: bool = True) -> xr.DataArray:
    """Extract decision variable array from backend dataset.

    Args:
        name (str): Name of variable.
        as_backend_objs (bool, optional): TODO: hide this and create a method to edit variables that handles differences in interface APIs.
            If True, will keep the array entries as backend interface objects,
            which can be updated to update the underlying model.
            Otherwise, variable values are given directly.
            If the model has not been successfully optimised, variable values will all be None.
            Defaults to True.

    Returns:
        xr.DataArray: Decision variable array.
    """

get_variable_bounds(name) abstractmethod

Extract decision variable upper and lower bound array from backend dataset.

Parameters:

Name	Type	Description	Default
name	str	Name of variable.	required

Returns:

Type	Description
Dataset	xr.Dataset: Contains the arrays for upper ("ub", a.k.a. "max") and lower ("lb", a.k.a. "min") variable bounds.

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def get_variable_bounds(self, name: str) -> xr.Dataset:
    """Extract decision variable upper and lower bound array from backend dataset.

    Args:
        name (str): Name of variable.

    Returns:
        xr.Dataset: Contains the arrays for upper ("ub", a.k.a. "max") and lower ("lb", a.k.a. "min") variable bounds.
    """

load_results()

Load and evaluate model results after a successful run.

Evaluates backend decision variables, global expressions, parameters (if not in inputs), and shadow_prices (if tracked).

Returns:

Type	Description
Dataset	xr.Dataset: Dataset of optimal solution results (all numeric data).

Source code in src/calliope/backend/backend_model.py

def load_results(self) -> xr.Dataset:
    """Load and evaluate model results after a successful run.

    Evaluates backend decision variables, global expressions, parameters (if not in
    inputs), and shadow_prices (if tracked).

    Returns:
        xr.Dataset: Dataset of optimal solution results (all numeric data).
    """

    def _drop_attrs(da):
        da.attrs = {
            k: v for k, v in da.attrs.items() if k in self._COMPONENT_ATTR_METADATA
        }
        return da

    all_variables = {
        name_: _drop_attrs(self.get_variable(name_, as_backend_objs=False))
        for name_, var in self.variables.items()
        if var.notnull().any()
    }
    all_global_expressions = {
        name_: _drop_attrs(
            self.get_global_expression(name_, as_backend_objs=False, eval_body=True)
        )
        for name_, expr in self.global_expressions.items()
        if expr.notnull().any()
    }

    all_shadow_prices = {
        f"shadow_price_{constraint}": self.shadow_prices.get(constraint)
        for constraint in self.shadow_prices.tracked
    }

    results = xr.Dataset(
        {**all_variables, **all_global_expressions, **all_shadow_prices}
    ).astype(float)

    return results

log(component_type, component_name, message, level='debug')

Log to module-level logger with some prettification of the message.

Parameters:

Name	Type	Description	Default
component_type	ALL_COMPONENTS_T	type of component.	required
component_name	str	name of the component.	required
message	str	message to log.	required
level	Literal['info', 'warning', 'debug', 'error', 'critical']	log level. Defaults to "debug".	'debug'

Source code in src/calliope/backend/backend_model.py

def log(
    self,
    component_type: ALL_COMPONENTS_T,
    component_name: str,
    message: str,
    level: Literal["info", "warning", "debug", "error", "critical"] = "debug",
):
    """Log to module-level logger with some prettification of the message.

    Args:
        component_type (ALL_COMPONENTS_T): type of component.
        component_name (str): name of the component.
        message (str): message to log.
        level (Literal["info", "warning", "debug", "error", "critical"], optional): log level. Defaults to "debug".
    """
    getattr(LOGGER, level)(
        f"Optimisation model | {component_type}:{component_name} | {message}"
    )

to_lp(path) abstractmethod

Write the optimisation problem to file in the linear programming LP format.

The LP file can be used for debugging and to submit to solvers directly.

Parameters:

Name	Type	Description	Default
path	str | Path	Path to which the LP file will be written.	required

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def to_lp(self, path: str | Path) -> None:
    """Write the optimisation problem to file in the linear programming LP format.

    The LP file can be used for debugging and to submit to solvers directly.

    Args:
        path (str | Path): Path to which the LP file will be written.
    """

unfix_variable(name, where=None) abstractmethod

Unfix the variable so that it is treated as a decision variable in the next call to solve.

Parameters:

Name	Type	Description	Default
name	str	Variable to update	required
where	DataArray | None	If provided, only a subset of the coordinates in the variable will be unfixed. Must be a boolean array or a float equivalent, where NaN is used instead of False. Defaults to None	None

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def unfix_variable(self, name: str, where: xr.DataArray | None = None) -> None:
    """Unfix the variable so that it is treated as a decision variable in the next call to `solve`.

    Args:
        name (str): Variable to update
        where (xr.DataArray | None, optional):
            If provided, only a subset of the coordinates in the variable will be unfixed.
            Must be a boolean array or a float equivalent, where NaN is used instead of False.
            Defaults to None
    """

update_parameter(name, new_values) abstractmethod

Update parameter elements using an array of new values.

If the parameter has not been previously defined, it will be added to the optimisation problem based on the new values given (with NaNs reverting to default values). If the new values have fewer dimensions than are on the parameter array, the new values will be broadcast across the missing dimensions before applying the update.

Parameters:

Name	Type	Description	Default
name	str	Parameter to update	required
new_values	DataArray | SupportsFloat	New values to apply. Any empty (NaN) elements in the array will be skipped.	required

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def update_parameter(
    self, name: str, new_values: xr.DataArray | SupportsFloat
) -> None:
    """Update parameter elements using an array of new values.

    If the parameter has not been previously defined, it will be added to the
    optimisation problem based on the new values given (with NaNs reverting to
    default values).
    If the new values have fewer dimensions than are on the parameter array, the
    new values will be broadcast across the missing dimensions before applying the
    update.

    Args:
        name (str): Parameter to update
        new_values (xr.DataArray | SupportsFloat): New values to apply. Any
            empty (NaN) elements in the array will be skipped.
    """

update_variable_bounds(name, *, min=None, max=None) abstractmethod

Update the bounds on a decision variable.

If the variable bounds are defined by parameters in the math formulation, the parameters themselves will be updated.

Parameters:

Name	Type	Description	Default
name	str	Variable to update.	required
min	DataArray | SupportsFloat | None	If provided, the Non-NaN values in the array will be used to defined new lower bounds in the decision variable. Defaults to None.	None
max	DataArray | SupportsFloat | None	If provided, the Non-NaN values in the array will be used to defined new upper bounds in the decision variable. Defaults to None.	None

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def update_variable_bounds(
    self,
    name: str,
    *,
    min: xr.DataArray | SupportsFloat | None = None,
    max: xr.DataArray | SupportsFloat | None = None,
) -> None:
    """Update the bounds on a decision variable.

    If the variable bounds are defined by parameters in the math formulation,
    the parameters themselves will be updated.

    Args:
        name (str): Variable to update.
        min (xr.DataArray | SupportsFloat | None, optional):
            If provided, the Non-NaN values in the array will be used to defined new lower bounds in the decision variable.
            Defaults to None.
        max (xr.DataArray | SupportsFloat | None, optional):
            If provided, the Non-NaN values in the array will be used to defined new upper bounds in the decision variable.
            Defaults to None.
    """

verbose_strings() abstractmethod

Update optimisation model object string representations to include the index coordinates of the object.

E.g., variables(flow_out)[0] will become variables(flow_out)[power, region1, ccgt, 2005-01-01 00:00]

This takes approximately 10% of the peak memory required to initially build the optimisation problem, so should only be invoked if inspecting the model in detail (e.g., debugging).

Only string representations of model parameters and variables will be updated since global expressions automatically show the string representation of their contents.

Source code in src/calliope/backend/backend_model.py

@abstractmethod
def verbose_strings(self) -> None:
    """Update optimisation model object string representations to include the index coordinates of the object.

    E.g., `variables(flow_out)[0]` will become `variables(flow_out)[power, region1, ccgt, 2005-01-01 00:00]`

    This takes approximately 10% of the peak memory required to initially build the
    optimisation problem, so should only be invoked if inspecting the model in
    detail (e.g., debugging).

    Only string representations of model parameters and variables will be updated
    since global expressions automatically show the string representation of their
    contents.
    """