carbatpy.optimizations.opti_de
==============================

.. py:module:: carbatpy.optimizations.opti_de


Functions
---------

.. autoapisummary::

   carbatpy.optimizations.opti_de.optimize


Module Contents
---------------

.. py:function:: optimize(mode: str, config: dict | str, boundaries: dict, same_fluid: bool = True, heat_losses: float = 0.0, COP: float | None = None, q_dot: float | None = None, verbose: bool = True, n_processes: int | None = None, maxtasksperchild: int = 20, n_ieq_constr: int = 3, pop_size: int = 50, sampling_iterations: int = 50, de_variant: str = 'DE/rand/1/bin', CR: float = 0.3, dither: str = 'vector', jitter: bool = False, n_gen: int = 100, period: int = 20, ftol: float = 0.0001, return_least_infeasible: bool = False)

   Perform the global optimization for the selected cycle.

   This function sets up the optimization problem, initializes the
   differential evolution algorithm, handles parallelization, and
   executes the optimization using Pymoo.

   :param mode: Optimization mode. Must be one of ``'hp'``, ``'orc'``, or ``'cb'``.
   :type mode: str
   :param config: Configuration dictionary or path to configuration file.
   :type config: dict | str
   :param boundaries: Lower and upper bounds for all optimization variables.
   :type boundaries: dict
   :param same_fluid: Whether the working fluid is the same for all cycles.
                      Only used in ``'cb'`` mode. Defaults to ``True``.
   :type same_fluid: bool
   :param heat_losses: Heat losses fraction.
                       Only used in ``'cb'`` mode. Defaults to ``0.0``.
   :type heat_losses: float
   :param COP: Coefficient of performance.
               Only used in ``'orc'`` mode.
   :type COP: float | None
   :param q_dot: Heat input/output rate.
                 Only used in ``'orc'`` mode.
   :type q_dot: float | None
   :param verbose: Whether to print detailed optimization progress.
                   Defaults to ``True``.
   :type verbose: bool
   :param n_processes: Number of processes for parallelization.
                       Defaults to auto-detection via :func:`default_n_processes`.
   :type n_processes: int | None
   :param maxtasksperchild: Maximum tasks per worker process in the pool.
                            Defaults to ``20``.
   :type maxtasksperchild: int
   :param n_ieq_constr: Number of inequality constraints. Defaults to ``3``.
   :type n_ieq_constr: int
   :param pop_size: Population size for the DE algorithm. Defaults to ``50``.
   :type pop_size: int
   :param sampling_iterations: Number of iterations for Latin Hypercube sampling.
                               Defaults to ``50``.
   :type sampling_iterations: int
   :param de_variant: Variant of the differential evolution algorithm.
                      Defaults to ``'DE/rand/1/bin'``.
   :type de_variant: str
   :param CR: Crossover probability for DE. Defaults to ``0.3``.
   :type CR: float
   :param dither: Dithering strategy for DE. Defaults to ``'vector'``.
   :type dither: str
   :param jitter: Whether to apply jitter in DE. Defaults to ``False``.
   :type jitter: bool
   :param n_gen: Maximum number of generations. Defaults to ``100``.
   :type n_gen: int
   :param period: Period for robust termination checking. Defaults to ``20``.
   :type period: int
   :param ftol: Function tolerance for termination. Defaults to ``1e-4``.
   :type ftol: float
   :param return_least_infeasible: Whether to return the least infeasible
                                   solution if no feasible solution is found. Defaults to ``False``.
   :type return_least_infeasible: bool

   :raises ValueError: If ``boundaries`` is ``None`` or required parameters for
       the selected ``mode`` are missing.

   :returns: The optimization result object containing
             the best solution and additional metadata.
   :rtype: pymoo.core.result.Result